//internal SafePeerNameEndResolve(bool ownsHandle) : base(ownsHandle) { } protected override bool ReleaseHandle() { UnsafeP2PNativeMethods.PeerPnrpEndResolve(handle); SetHandleAsInvalid(); //Mark it closed - This does not change the value of the handle it self SetHandle(IntPtr.Zero); //Mark it invalid - Change the value to Zero return(true); }
internal void StartAsyncResolve() { //------------------------------------------ //Check for disposal //------------------------------------------ if (m_Disposed) { throw new ObjectDisposedException(this.GetType().FullName); } //------------------------------------------ //First wire up a callback //------------------------------------------ m_RegisteredWaitHandle = ThreadPool.RegisterWaitForSingleObject(m_EndPointInfoAvailableEvent, //Event that triggers the callback new WaitOrTimerCallback(EndPointInfoAvailableCallback), //callback to be called null, //state to be passed -1, //Timeout - aplicable only for timers not for events false //call us everytime the event is set not just one time ); //------------------------------------------ //Now call the native API to start the resolution //process save the handle for later //------------------------------------------ Int32 result = UnsafeP2PNativeMethods.PeerPnrpStartResolve(m_PeerName.ToString(), m_Cloud.InternalName, (UInt32)m_MaxRecords, m_EndPointInfoAvailableEvent.SafeWaitHandle, out m_SafePeerNameEndResolve); if (result != 0) { if (!m_SafePeerNameEndResolve.IsInvalid && !m_SafePeerNameEndResolve.IsClosed) { m_SafePeerNameEndResolve.Dispose(); } m_RegisteredWaitHandle.Unregister(null); m_RegisteredWaitHandle = null; PeerToPeerException ex = PeerToPeerException.CreateFromHr(SR.GetString(SR.Pnrp_CouldNotStartNameResolution), result); Logging.P2PTraceSource.TraceEvent(TraceEventType.Error, m_TraceEventId, "Exception occurred while starting async resolve"); throw ex; } //------------------------------------------ //Create an async operation with the given //user state //------------------------------------------ m_AsyncOp = AsyncOperationManager.CreateOperation(m_userState); Logging.P2PTraceSource.TraceEvent(TraceEventType.Information, m_TraceEventId, "Successfully started the async resolve. The native handle is {0}", m_SafePeerNameEndResolve.DangerousGetHandle()); }
public static PeerName CreateFromPeerHostName(string peerHostName) { //------------------------------------------------- //Check arguments //------------------------------------------------- if (peerHostName == null) { throw new ArgumentNullException("peerHostName"); } if (peerHostName.Length == 0) { throw new ArgumentException(SR.GetString(SR.Pnrp_InvalidPeerHostName), "peerHostName"); } Int32 result; SafePeerData shPeerName = null; string peerName = null; try { result = UnsafeP2PNativeMethods.PeerHostNameToPeerName(peerHostName, out shPeerName); if (result != 0) { throw PeerToPeerException.CreateFromHr(SR.GetString(SR.Pnrp_CouldNotGetPeerNameFromPeerHostName), result); } peerName = shPeerName.UnicodeString; } finally { if (shPeerName != null) { shPeerName.Dispose(); } } string authority; string classifier; WeakParsePeerName(peerName, out authority, out classifier); PeerName p = new PeerName(peerName, authority, classifier); Logging.P2PTraceSource.TraceEvent(TraceEventType.Information, 0, "PeerName created from PeerHostName - PeerHostName {0} to PeerName PeerName {1} Authority {2} Classfier {3}", peerHostName, peerName, authority, classifier); return(p); }
public static PeerName CreateRelativePeerName( PeerName peerName, string classifier) { //------------------------------------------------- //Check arguments //------------------------------------------------- if (peerName == null) { throw new ArgumentNullException("peerName", SR.GetString(SR.Pnrp_PeerNameCantBeNull)); } if (!peerName.IsSecured && (classifier == null || classifier.Length == 0)) { throw new ArgumentException(SR.GetString(SR.Pnrp_InvalidClassifier), "classifier"); } if (classifier != null && classifier.Length > PEER_MAX_CLASSIFIER_LENGTH) { throw new ArgumentException(SR.GetString(SR.Pnrp_InvalidClassifier), "classifier"); } //-------------------------------------------------- //Normalize using NFC //-------------------------------------------------- if (classifier != null && classifier.Length > 0) { classifier = classifier.Normalize(NormalizationForm.FormC); } Int32 result; SafePeerData shNewPeerName = null; string newPeerName = null; try { //Here there is change made on the native side //when passing secured peer names, it takes string of the form [40hexdigits].claasisifer and a newclassifier //returns [40hexdigits.newclassifier] //But for unsecured peer names it does not take 0.clasfier and newclassfier to return 0.newclassfier. //It expects NULL as the first param. To satisfy this broken finctionality, we are passing null if the //peer name is unsecured. result = UnsafeP2PNativeMethods.PeerCreatePeerName(peerName.IsSecured? peerName.m_PeerName : null, classifier, out shNewPeerName); if (result != 0) { throw PeerToPeerException.CreateFromHr(SR.GetString(SR.Pnrp_CouldNotCreateRelativePeerName), result); } newPeerName = shNewPeerName.UnicodeString; } finally { if (shNewPeerName != null) { shNewPeerName.Dispose(); } } string authority; string newClassifier; WeakParsePeerName(newPeerName, out authority, out newClassifier); PeerName p = new PeerName(newPeerName, authority, newClassifier); Logging.P2PTraceSource.TraceEvent(TraceEventType.Information, 0, "A new PeerName created from existing PeerName with a new classfier. Existing PeerName {0} Classifier {1} New PeerName {2}", peerName, classifier, p); return(p); }
public PeerName(string classifier, PeerNameType peerNameType) { //------------------------------------------------- //Check arguments //------------------------------------------------- if ((classifier == null || classifier.Length == 0) && peerNameType == PeerNameType.Unsecured) { throw new ArgumentNullException("classifier"); } if (classifier != null && classifier.Length > PEER_MAX_CLASSIFIER_LENGTH) { throw new ArgumentException(SR.GetString(SR.Pnrp_InvalidClassifier), "classifier"); } //-------------------------------------------------- //Normalize using NFC //-------------------------------------------------- if (classifier != null && classifier.Length > 0) { classifier = classifier.Normalize(NormalizationForm.FormC); } //------------------------------------------------- //call the helper to create the PeerName //------------------------------------------------- Int32 result; SafePeerData shNewPeerName = null; SafePeerData shDefaultIdentity = null; try { if (peerNameType == PeerNameType.Unsecured) { result = UnsafeP2PNativeMethods.PeerCreatePeerName((string)null, classifier, out shNewPeerName); if (result != 0) { throw PeerToPeerException.CreateFromHr(SR.GetString(SR.Pnrp_CouldNotCreateUnsecuredPeerName), result); } m_Authority = PEERNAME_UNSECURED_AUTHORITY; } else { result = UnsafeP2PNativeMethods.PeerIdentityGetDefault(out shDefaultIdentity); if (result != 0) { throw PeerToPeerException.CreateFromHr(SR.GetString(SR.Pnrp_CouldNotGetDefaultIdentity), result); } m_Authority = shDefaultIdentity.UnicodeString; //} result = UnsafeP2PNativeMethods.PeerCreatePeerName(m_Authority, classifier, out shNewPeerName); if (result != 0) { throw PeerToPeerException.CreateFromHr(SR.GetString(SR.Pnrp_CouldNotCreateSecuredPeerName), result); } } m_PeerName = shNewPeerName.UnicodeString; m_Classifier = classifier; } finally { if (shNewPeerName != null) { shNewPeerName.Dispose(); } if (shDefaultIdentity != null) { shDefaultIdentity.Dispose(); } } Logging.P2PTraceSource.TraceEvent(TraceEventType.Information, 0, "PeerName instance created - PeerName {0} Authority {1} Classfier {2}", m_PeerName, m_Authority, m_Classifier); }
public void ResolveAsync(PeerName peerName, Cloud cloud, int maxRecords, object userState) { //------------------------------------------------- //Check arguments //------------------------------------------------- if (peerName == null) { throw new ArgumentNullException(SR.GetString(SR.Pnrp_PeerNameCantBeNull), "peerName"); } if (cloud == null) { cloud = Cloud.Available; } if (maxRecords <= 0) { throw new ArgumentOutOfRangeException("maxRecords", SR.GetString(SR.Pnrp_MaxRecordsParameterMustBeGreaterThanZero)); } if (m_ResolveCompleted == null) { throw new PeerToPeerException(SR.GetString(SR.Pnrp_AtleastOneEvenHandlerNeeded)); } //--------------------------------------------------- //Demand CAS permissions //--------------------------------------------------- PnrpPermission.UnrestrictedPnrpPermission.Demand(); //--------------------------------------------------------------- //No perf hit here, real native call happens only one time if it //did not already happen //--------------------------------------------------------------- UnsafeP2PNativeMethods.PnrpStartup(); //---------------------------------------------------- //userToken can't be null //---------------------------------------------------- if (userState == null) { throw new ArgumentNullException(SR.GetString(SR.NullUserToken), "userState"); } PeerNameResolverHelper peerNameResolverHelper = null; //--------------------------------------------------- //The userToken can't be duplicate of what is in the //current list. These are the requriments for the new Async model //that supports multiple outstanding async calls //--------------------------------------------------- int newTraceEventId = NewTraceEventId; lock (m_PeerNameResolverHelperListLock) { if (m_PeerNameResolverHelperList.ContainsKey(userState)) { throw new ArgumentException(SR.GetString(SR.DuplicateUserToken)); } Logging.P2PTraceSource.TraceEvent(TraceEventType.Information, newTraceEventId, "PeerNameResolverHelper is being created with TraceEventId {0}", newTraceEventId); peerNameResolverHelper = new PeerNameResolverHelper(peerName, cloud, maxRecords, userState, this, newTraceEventId); m_PeerNameResolverHelperList[userState] = peerNameResolverHelper; } try { //--------------------------------------------------- //Start resolution on that resolver //--------------------------------------------------- peerNameResolverHelper.StartAsyncResolve(); } catch { //--------------------------------------------------- //If an exception happens clear the userState from the //list so that that token can be reused //--------------------------------------------------- lock (m_PeerNameResolverHelperListLock) { m_PeerNameResolverHelperList.Remove(userState); Logging.P2PTraceSource.TraceEvent(TraceEventType.Error, newTraceEventId, "Removing userState token from pending list {0}", userState.GetHashCode()); } throw; } }
public PeerNameRecordCollection Resolve(PeerName peerName, Cloud cloud, int maxRecords) { //--------------------------------------------------- //Check arguments //--------------------------------------------------- if (peerName == null) { throw new ArgumentNullException(SR.GetString(SR.Pnrp_PeerNameCantBeNull), "peerName"); } if (maxRecords <= 0) { throw new ArgumentOutOfRangeException("maxRecords", SR.GetString(SR.Pnrp_MaxRecordsParameterMustBeGreaterThanZero)); } //--------------------------------------------------- //Assume all clouds if the clould passed is null? //--------------------------------------------------- if (cloud == null) { cloud = Cloud.Available; } //--------------------------------------------------- //Demand CAS permissions //--------------------------------------------------- PnrpPermission.UnrestrictedPnrpPermission.Demand(); //--------------------------------------------------------------- //No perf hit here, real native call happens only one time if it //did not already happen //--------------------------------------------------------------- UnsafeP2PNativeMethods.PnrpStartup(); //--------------------------------------------------------------- //Trace log //--------------------------------------------------------------- Logging.P2PTraceSource.TraceEvent(TraceEventType.Information, 0, "Sync Resolve called with PeerName: {0}, Cloud: {1}, MaxRecords {2}", peerName, cloud, maxRecords); SafePeerData shEndPointInfoArray; string NativeCloudName = cloud.InternalName; UInt32 ActualCountOfEndPoints = (UInt32)maxRecords; int result = UnsafeP2PNativeMethods.PeerPnrpResolve(peerName.ToString(), NativeCloudName, ref ActualCountOfEndPoints, out shEndPointInfoArray); if (result != 0) { throw PeerToPeerException.CreateFromHr(SR.GetString(SR.Pnrp_CouldNotStartNameResolution), result); } //--------------------------------------------------- //If there are no endpoints returned, return //an empty PeerNameRecord Collection //--------------------------------------------------- PeerNameRecordCollection PeerNameRecords = new PeerNameRecordCollection(); if (ActualCountOfEndPoints != 0) { try { unsafe { IntPtr pEndPointInfoArray = shEndPointInfoArray.DangerousGetHandle(); PEER_PNRP_ENDPOINT_INFO *pEndPoints = (PEER_PNRP_ENDPOINT_INFO *)pEndPointInfoArray; for (int i = 0; i < ActualCountOfEndPoints; i++) { PeerNameRecord record = new PeerNameRecord(); PEER_PNRP_ENDPOINT_INFO *pEndPointInfo = &pEndPoints[i]; record.PeerName = new PeerName(Marshal.PtrToStringUni(pEndPointInfo->pwszPeerName)); string comment = Marshal.PtrToStringUni(pEndPointInfo->pwszComment); if (comment != null && comment.Length > 0) { record.Comment = comment; } if (pEndPointInfo->payLoad.cbPayload != 0) { record.Data = new byte[pEndPointInfo->payLoad.cbPayload]; Marshal.Copy(pEndPointInfo->payLoad.pbPayload, record.Data, 0, (int)pEndPointInfo->payLoad.cbPayload); } //record.EndPointList = new IPEndPoint[pEndPointInfo->cAddresses]; IntPtr ppSOCKADDRs = pEndPointInfo->ArrayOfSOCKADDRIN6Pointers; for (UInt32 j = 0; j < pEndPointInfo->cAddresses; j++) { IntPtr pSOCKADDR = Marshal.ReadIntPtr(ppSOCKADDRs); byte[] AddressFamilyBuffer = new byte[2]; Marshal.Copy(pSOCKADDR, AddressFamilyBuffer, 0, 2); int addressFamily = 0; #if BIGENDIAN addressFamily = AddressFamilyBuffer[1] + ((int)AddressFamilyBuffer[0] << 8); #else addressFamily = AddressFamilyBuffer[0] + ((int)AddressFamilyBuffer[1] << 8); #endif byte[] buffer = new byte[((AddressFamily)addressFamily == AddressFamily.InterNetwork) ? SystemNetHelpers.IPv4AddressSize : SystemNetHelpers.IPv6AddressSize]; Marshal.Copy(pSOCKADDR, buffer, 0, buffer.Length); IPEndPoint ipe = SystemNetHelpers.IPEndPointFromSOCKADDRBuffer(buffer); record.EndPointCollection.Add(ipe); ppSOCKADDRs = (IntPtr)((long)ppSOCKADDRs + Marshal.SizeOf(typeof(IntPtr))); } //---------------------------------- //Dump for trace //---------------------------------- record.TracePeerNameRecord(); //---------------------------------- //Add to collection //---------------------------------- PeerNameRecords.Add(record); } } } finally { shEndPointInfoArray.Dispose(); } } Logging.P2PTraceSource.TraceEvent(TraceEventType.Information, 0, "Sync Resolve returnig with PeerNameRecord count :{0}", PeerNameRecords.Count); return(PeerNameRecords); }
public void EndPointInfoAvailableCallback(object state, bool timedOut) { //------------------------------------------ //This callback is called whenever there is an endpoint info //available or the resultion is completed //------------------------------------------ Logging.P2PTraceSource.TraceEvent(TraceEventType.Information, m_TraceEventId, "EndPointInfoAvailableCallback called"); PeerNameRecord record = null; SafePeerData shEndPointInfo; Int32 result = 0; PeerNameResolver parent = null; if (m_Cancelled) { Logging.P2PTraceSource.TraceEvent(TraceEventType.Information, m_TraceEventId, "Detected that the async operation is already canceled - before entering the lock"); return; } lock (m_Lock) { if (m_Cancelled) { Logging.P2PTraceSource.TraceEvent(TraceEventType.Information, m_TraceEventId, "Detected that the async operation is already canceled - after entering the lock"); return; } result = UnsafeP2PNativeMethods.PeerPnrpGetEndpoint(m_SafePeerNameEndResolve.DangerousGetHandle(), out shEndPointInfo); if (result != 0) { if (result == PEER_E_NO_MORE) { Logging.P2PTraceSource.TraceEvent(TraceEventType.Information, m_TraceEventId, "Native API returned that there are no more records - resolve completed successfully"); } m_CompletedOrException = true; m_SafePeerNameEndResolve.Dispose(); } else { Logging.P2PTraceSource.TraceEvent(TraceEventType.Information, m_TraceEventId, "Proceeding to retrieve the endpoint information from incremental resolve"); try { unsafe { PEER_PNRP_ENDPOINT_INFO *pEndPointInfo = (PEER_PNRP_ENDPOINT_INFO *)shEndPointInfo.DangerousGetHandle(); record = new PeerNameRecord(); record.PeerName = new PeerName(Marshal.PtrToStringUni(pEndPointInfo->pwszPeerName)); string comment = Marshal.PtrToStringUni(pEndPointInfo->pwszComment); if (comment != null && comment.Length > 0) { record.Comment = comment; } if (pEndPointInfo->payLoad.cbPayload != 0) { record.Data = new byte[pEndPointInfo->payLoad.cbPayload]; Marshal.Copy(pEndPointInfo->payLoad.pbPayload, record.Data, 0, (int)pEndPointInfo->payLoad.cbPayload); } //record.EndPointList = new IPEndPoint[pEndPointInfo->cAddresses]; IntPtr ppSOCKADDRs = pEndPointInfo->ArrayOfSOCKADDRIN6Pointers; for (UInt32 j = 0; j < pEndPointInfo->cAddresses; j++) { IntPtr pSOCKADDR = Marshal.ReadIntPtr(ppSOCKADDRs); byte[] AddressFamilyBuffer = new byte[2]; Marshal.Copy(pSOCKADDR, AddressFamilyBuffer, 0, 2); int addressFamily = 0; #if BIGENDIAN addressFamily = AddressFamilyBuffer[1] + ((int)AddressFamilyBuffer[0] << 8); #else addressFamily = AddressFamilyBuffer[0] + ((int)AddressFamilyBuffer[1] << 8); #endif byte[] buffer = new byte[((AddressFamily)addressFamily == AddressFamily.InterNetwork) ? SystemNetHelpers.IPv4AddressSize : SystemNetHelpers.IPv6AddressSize]; Marshal.Copy(pSOCKADDR, buffer, 0, buffer.Length); IPEndPoint ipe = SystemNetHelpers.IPEndPointFromSOCKADDRBuffer(buffer); record.EndPointCollection.Add(ipe); ppSOCKADDRs = (IntPtr)((long)ppSOCKADDRs + Marshal.SizeOf(typeof(IntPtr))); } } } finally { shEndPointInfo.Dispose(); } record.TracePeerNameRecord(); m_PeerNameRecordCollection.Add(record); ResolveProgressChangedEventArgs resolveProgressChangedEventArgs = new ResolveProgressChangedEventArgs( record, m_AsyncOp.UserSuppliedState); Logging.P2PTraceSource.TraceEvent(TraceEventType.Information, m_TraceEventId, "Proceeding to call progress changed event callback"); parent = m_PeerNameResolverWeakReference.Target as PeerNameResolver; if (parent != null) { parent.PrepareToRaiseProgressChangedEvent(m_AsyncOp, resolveProgressChangedEventArgs); } return; } } ResolveCompletedEventArgs resolveCompletedEventArgs; if (result == PEER_E_NO_MORE) { resolveCompletedEventArgs = new ResolveCompletedEventArgs(m_PeerNameRecordCollection, null, false, m_AsyncOp.UserSuppliedState); } else { PeerToPeerException ex = PeerToPeerException.CreateFromHr(SR.GetString(SR.Pnrp_ExceptionWhileResolvingAPeerName), result); Logging.P2PTraceSource.TraceEvent(TraceEventType.Information, m_TraceEventId, "Exception occurred when the native API is called to harvest an incremental resolve notification"); resolveCompletedEventArgs = new ResolveCompletedEventArgs(null, ex, false, m_AsyncOp.UserSuppliedState); } parent = m_PeerNameResolverWeakReference.Target as PeerNameResolver; if (parent != null) { Logging.P2PTraceSource.TraceEvent(TraceEventType.Information, m_TraceEventId, "Proceeding to call the ResolveCompleted callback"); parent.PrepareToRaiseCompletedEvent(m_AsyncOp, resolveCompletedEventArgs); } return; }
public void Update() { //------------------------------------------------- //Check for the dead object //------------------------------------------------- if (m_Disposed) { throw new ObjectDisposedException(this.GetType().FullName); } //------------------------------------------------- //If there is no existing registration to update //get out //------------------------------------------------- if (!IsRegistered()) { throw new InvalidOperationException(SR.GetString(SR.Pnrp_CallRegisterBeforeUpdate)); } //------------------------------------------------- //Check for parameters //------------------------------------------------- if (m_PeerNameRecord.PeerName == null) { throw new ArgumentNullException(SR.GetString(SR.Pnrp_InvalidPeerName)); } //------------------------------------------------- //If the current PeerName associated with the //current registration is not the same as the //PeerName given now - throw //------------------------------------------------- if (!m_RegisteredPeerName.Equals(m_PeerNameRecord.PeerName)) { throw new InvalidOperationException(SR.GetString(SR.Pnrp_CantChangePeerNameAfterRegistration)); } //------------------------------------------ //If auto address selection is turned off //then there must be atleast Data or Endpoints //specified //------------------------------------------ if (!m_UseAutoEndPointSelection) { if ((EndPointCollection.Count == 0) || (Data == null || Data.Length <= 0)) { throw new PeerToPeerException(SR.GetString(SR.Pnrp_BlobOrEndpointListNeeded)); } } //------------------------------------------------- //Demand for the Unrestricted Pnrp Permission //------------------------------------------------- PnrpPermission.UnrestrictedPnrpPermission.Demand(); //--------------------------------------------------------------- //Log trace info //--------------------------------------------------------------- if (Logging.P2PTraceSource.Switch.ShouldTrace(TraceEventType.Information)) { Logging.P2PTraceSource.TraceEvent(TraceEventType.Information, 0, "Update() is called with the following Info"); m_PeerNameRecord.TracePeerNameRecord(); } PEER_PNRP_REGISTRATION_INFO regInfo = new PEER_PNRP_REGISTRATION_INFO(); //------------------------------------------------- //Set data //------------------------------------------------- if (m_PeerNameRecord.Data != null) { regInfo.payLoad.cbPayload = (UInt32)m_PeerNameRecord.Data.Length; //Marshal.All //regInfo.payLoad.pbPayload = m_PeerNameRecord.Data; GCHandle handle = GCHandle.Alloc(m_PeerNameRecord.Data, GCHandleType.Pinned); regInfo.payLoad.pbPayload = handle.AddrOfPinnedObject(); //m_PeerNameRecord.Data; handle.Free(); } ; //------------------------------------------------- //Set comment //------------------------------------------------- if (m_PeerNameRecord.Comment != null && m_PeerNameRecord.Comment.Length > 0) { regInfo.pwszComment = m_PeerNameRecord.Comment; } //------------------------------------------------- //Set cloud name //------------------------------------------------- regInfo.pwszCloudName = null; if (m_Cloud != null) { regInfo.pwszCloudName = m_Cloud.InternalName; } if (m_PeerNameRecord.EndPointCollection.Count == 0) { //------------------------------------------------- //Set port only if the addresses are null //and then set the selection to auto addresses //------------------------------------------------- regInfo.wport = (ushort)m_Port; regInfo.cAddresses = PEER_PNRP_AUTO_ADDRESSES; int result = UnsafeP2PNativeMethods.PeerPnrpUpdateRegistration(m_RegistrationHandle, ref regInfo); if (result != 0) { throw PeerToPeerException.CreateFromHr(SR.GetString(SR.Pnrp_CouldNotRegisterPeerName), result); } return; } else { //------------------------------------------------- //Set the Endpoint List //------------------------------------------------- int numAddresses = m_PeerNameRecord.EndPointCollection.Count; int cbRequriedBytes = numAddresses * Marshal.SizeOf(typeof(IntPtr)); IntPtr pSocketAddrList = Marshal.AllocHGlobal(cbRequriedBytes); GCHandle[] GCHandles = new GCHandle[numAddresses]; try { unsafe { IntPtr *pAddress = (IntPtr *)pSocketAddrList; for (int i = 0; i < m_PeerNameRecord.EndPointCollection.Count; i++) { byte[] sockaddr = SystemNetHelpers.SOCKADDRFromIPEndPoint(m_PeerNameRecord.EndPointCollection[i]); GCHandles[i] = GCHandle.Alloc(sockaddr, GCHandleType.Pinned); IntPtr psockAddr = GCHandles[i].AddrOfPinnedObject(); pAddress[i] = psockAddr; } } regInfo.ArrayOfSOCKADDRIN6Pointers = pSocketAddrList; regInfo.cAddresses = (UInt32)numAddresses; int result = UnsafeP2PNativeMethods.PeerPnrpUpdateRegistration(m_RegistrationHandle, ref regInfo); if (result != 0) { throw PeerToPeerException.CreateFromHr(SR.GetString(SR.Pnrp_CouldNotRegisterPeerName), result); } } finally { if (pSocketAddrList != IntPtr.Zero) { Marshal.FreeHGlobal(pSocketAddrList); } for (int i = 0; i < GCHandles.Length; i++) { if (GCHandles[i].IsAllocated) { GCHandles[i].Free(); } } } Logging.P2PTraceSource.TraceEvent(TraceEventType.Information, 0, "Update of existing registration is successful. The handle is {0}", m_RegistrationHandle.DangerousGetHandle()); } }
private void InternalRegister() { //------------------------------------------ //If we already registered, get out this place //------------------------------------------ if (m_IsRegistered) { throw new PeerToPeerException(SR.GetString(SR.Pnrp_UseUpdateInsteadOfRegister)); } //------------------------------------------ //Make sure you have the required info //------------------------------------------ if (m_PeerNameRecord.PeerName == null) { throw new ArgumentNullException("PeerName"); } //------------------------------------------ //If auto address selection is turned off //then there must be atleast Data or Endpoints //specified //------------------------------------------ if (!m_UseAutoEndPointSelection) { if ((EndPointCollection.Count == 0) && (Data == null || Data.Length <= 0)) { throw new PeerToPeerException(SR.GetString(SR.Pnrp_BlobOrEndpointListNeeded)); } } //------------------------------------------------- //Demand for the Unrestricted Pnrp Permission //------------------------------------------------- PnrpPermission.UnrestrictedPnrpPermission.Demand(); //--------------------------------------------------------------- //No perf hit here, real native call happens only one time if it //did not already happen //--------------------------------------------------------------- UnsafeP2PNativeMethods.PnrpStartup(); //--------------------------------------------------------------- //Log trace info //--------------------------------------------------------------- if (Logging.P2PTraceSource.Switch.ShouldTrace(TraceEventType.Information)) { Logging.P2PTraceSource.TraceEvent(TraceEventType.Information, 0, "InternalRegister() is called with the following Info"); m_PeerNameRecord.TracePeerNameRecord(); } PEER_PNRP_REGISTRATION_INFO regInfo = new PEER_PNRP_REGISTRATION_INFO(); GCHandle handle; //------------------------------------------------- //Set data //------------------------------------------------- if (m_PeerNameRecord.Data != null) { regInfo.payLoad.cbPayload = (UInt32)m_PeerNameRecord.Data.Length; handle = GCHandle.Alloc(m_PeerNameRecord.Data, GCHandleType.Pinned); regInfo.payLoad.pbPayload = handle.AddrOfPinnedObject(); //m_PeerNameRecord.Data; } else { handle = new GCHandle(); } //------------------------------------------------- //Set comment //------------------------------------------------- if (m_PeerNameRecord.Comment != null && m_PeerNameRecord.Comment.Length > 0) { regInfo.pwszComment = m_PeerNameRecord.Comment; } //------------------------------------------------- //Set cloud name //------------------------------------------------- if (m_Cloud != null) { regInfo.pwszCloudName = m_Cloud.InternalName; } try { if (m_PeerNameRecord.EndPointCollection.Count == 0) { //------------------------------------------------- //Set port only if the addresses are null //and then set the selection to auto addresses //------------------------------------------------- regInfo.wport = (ushort)m_Port; if (m_UseAutoEndPointSelection) { regInfo.cAddresses = PEER_PNRP_AUTO_ADDRESSES; } //------------------------------------------------- //Call the native API to register //------------------------------------------------- int result = UnsafeP2PNativeMethods.PeerPnrpRegister(m_PeerNameRecord.PeerName.ToString(), ref regInfo, out m_RegistrationHandle); if (result != 0) { throw PeerToPeerException.CreateFromHr(SR.GetString(SR.Pnrp_CouldNotRegisterPeerName), result); } } else { //------------------------------------------------- //Set the Endpoint List //------------------------------------------------- int numAddresses = m_PeerNameRecord.EndPointCollection.Count; int cbRequriedBytes = numAddresses * Marshal.SizeOf(typeof(IntPtr)); IntPtr pSocketAddrList = Marshal.AllocHGlobal(cbRequriedBytes); GCHandle[] GCHandles = new GCHandle[numAddresses]; try { unsafe { IntPtr *pAddress = (IntPtr *)pSocketAddrList; for (int i = 0; i < m_PeerNameRecord.EndPointCollection.Count; i++) { byte[] sockaddr = SystemNetHelpers.SOCKADDRFromIPEndPoint(m_PeerNameRecord.EndPointCollection[i]); GCHandles[i] = GCHandle.Alloc(sockaddr, GCHandleType.Pinned); IntPtr psockAddr = GCHandles[i].AddrOfPinnedObject(); pAddress[i] = psockAddr; } } regInfo.ArrayOfSOCKADDRIN6Pointers = pSocketAddrList; regInfo.cAddresses = (UInt32)numAddresses; int result = UnsafeP2PNativeMethods.PeerPnrpRegister(m_PeerNameRecord.PeerName.ToString(), ref regInfo, out m_RegistrationHandle); if (result != 0) { throw PeerToPeerException.CreateFromHr(SR.GetString(SR.Pnrp_CouldNotRegisterPeerName), result); } } finally { if (pSocketAddrList != IntPtr.Zero) { Marshal.FreeHGlobal(pSocketAddrList); } for (int i = 0; i < GCHandles.Length; i++) { if (GCHandles[i].IsAllocated) { GCHandles[i].Free(); } } } } } finally { if (handle.IsAllocated) { handle.Free(); } } m_RegisteredPeerName = m_PeerNameRecord.PeerName; m_IsRegistered = true; Logging.P2PTraceSource.TraceEvent(TraceEventType.Information, 0, "Registration is successful. The handle is {0}", m_RegistrationHandle.DangerousGetHandle()); }
private static void GetCloudOrClouds(string cloudName, bool bGlobalCloudOnly, out CloudCollection clouds, out Cloud cloud) { cloud = null; clouds = null; Logging.Enter(Logging.P2PTraceSource, "Cloud::GetCloudOrClouds()"); //------------------------------------------------- //Demand for the Unrestricted Pnrp Permission //------------------------------------------------- PnrpPermission.UnrestrictedPnrpPermission.Demand(); Int32 result = 0; UInt32 numClouds = 0; SafePeerData ArrayOfCloudInfoStructures = null; if (cloudName == null) { //----------------------------------------- //We need the collection only when we are not //getting a specific cloud //----------------------------------------- clouds = new CloudCollection(); } try { //--------------------------------------------------------------- //No perf hit here, real native call happens only one time if it //did not already happen //--------------------------------------------------------------- UnsafeP2PNativeMethods.PnrpStartup(); result = UnsafeP2PNativeMethods.PeerPnrpGetCloudInfo(out numClouds, out ArrayOfCloudInfoStructures); if (result != 0) { throw PeerToPeerException.CreateFromHr(SR.GetString(SR.Pnrp_CouldNotEnumerateClouds), result); } if (numClouds != 0) { Logging.P2PTraceSource.TraceEvent(TraceEventType.Information, 0, "Number of clouds returned {0}", numClouds); IntPtr pPEER_PNRP_CLOUD_INFO = ArrayOfCloudInfoStructures.DangerousGetHandle(); for (ulong i = 0; i < numClouds; i++) { PEER_PNRP_CLOUD_INFO cloudinfo = (PEER_PNRP_CLOUD_INFO)Marshal.PtrToStructure(pPEER_PNRP_CLOUD_INFO, typeof(PEER_PNRP_CLOUD_INFO)); string nativeCloudName = Marshal.PtrToStringUni(cloudinfo.pwzCloudName); pPEER_PNRP_CLOUD_INFO = (IntPtr)((long)pPEER_PNRP_CLOUD_INFO + Marshal.SizeOf(typeof(PEER_PNRP_CLOUD_INFO))); Cloud c = new Cloud(nativeCloudName, (PnrpScope)((int)cloudinfo.dwScope), (int)cloudinfo.dwScopeId); if (cloudName == null && !bGlobalCloudOnly) { clouds.Add(c); continue; } //If a specific cloud by name is required, then test for name //note that scope is PnrpScope.All but we don't test that now if (cloudName != null && cloudName == nativeCloudName) { cloud = c; break; } if (bGlobalCloudOnly && c.Scope == PnrpScope.Global) { cloud = c; break; } } } else { Logging.P2PTraceSource.TraceEvent(TraceEventType.Warning, 0, "No Clouds returned from the native call"); } } finally { if (ArrayOfCloudInfoStructures != null) { ArrayOfCloudInfoStructures.Dispose(); } } if (cloudName != null && cloud == null) { Logging.P2PTraceSource.TraceEvent(TraceEventType.Information, 0, "The specific cloud name {0} asked for is not found", cloudName); } Logging.Leave(Logging.P2PTraceSource, "Cloud::GetCloudOrClouds()"); }