Moore's Mind

Peer Collaboration - Inviting

2006-05-01T11:16:00.000-07:00

My third article about Peer Collaboration - Inviting in Windows Vista has been posted at Code Project. Next topic will be about Contacts.

Peer Collaboration - Application Registration

2006-04-24T14:14:00.000-07:00

My second article about Peer Collaboration - Application Registration has been posted at Code Project. Next up is Invitations to People Near Me. Enjoy.

People Near Me Article Posted

2006-04-24T09:20:00.000-07:00

My first article about Peer Collaboration - People Near Me has just been posted on Code Project.

Here's a video and useful comments about Vista Collaboration over at Channel 9.

Well-known security identifiers in Windows operating systems

2006-04-19T05:27:00.000-07:00

If you ever poke around the registry like I do from time to time and wondered what all those SID's are under HKEY_USERS, then this KB article will be useful: Well-known security identifiers in Windows operating systems

PEER_APPLICATION_ALL_USERS

2006-04-18T20:24:00.000-07:00

I've been using the PeerCollabRegisterApplication API to register applications. When the registration type is PEER_APPLICATION_CURRENT_USER it makes sense. However, when the registration type is PEER_APPLICATION_ALL_USERS, I see an odd behavior. Under User1 account, I register Notepad for All Users. When I login to User2 account and enumerate what's registered for All Users, I would expect to see Notepad, however, I don't.

I'm using the February CTP of Windows Vista. Any comments is appreciated.

PEER_EVENT_PEOPLE_NEAR_ME_CHANGED

2006-04-16T07:31:00.000-07:00

So in my first article about the new peer-to-peer collaboration features in Windows Vista, I came across something interesting.

After registering for events, I successfully get notifications when a user account on the subnet signs into People Near Me.

I noticed that when the screen saver kicks in, collaboration applications receieve a DELETED event. I suppose this makes sense, since the screen saver is set to force the user to re-login.

I also noticed that when remote user accounts that are signed-in, log out, there is no DELETED event. I think this might be a bug. I'm only testing with multiple virtual machines on one computer, but the behavior is inconsistent with what I'd expect.

Writing Article Again and MVP

2006-04-16T07:29:00.000-07:00

After a couple of months break, I'm finally back to writing peer-to-peer articles. Expect the next one in a couple of days.

During this break, I was awarded a Microsoft MVP for Windows Networking. Besides recognition of my contribution to the public domain, it comes with some goodies, including a much needed MSDN media set.

Tripp / Ravi, if you had anything to do with this, a BIG thanks to you.

2006-02-27T05:33:00.000-08:00

Just installed the February CTP of Vista, when I call PeerCollabSignin to sign-in, a PEER_E_PRIVACY_DECLINED error is returned. There is no documentation on this error code.

I'm guessing, its because I haven't visited Control Panel, People Near Me and agreed to the privacy statement.

When I run the Windows Collaboration application, it appears to launch a COM surrogate process that pops up the "Set up People Near Me" window and gets me to set my display name and agree to the privacy statement.

In my opinion, this same behavior should be built-in to the PeerCollabSignin method when the sign-in flags are either NEARME or ALL.

Comments are welcome.

Bug in PeerGroupIssueCredentials

2006-02-25T07:17:00.000-08:00

After trying to figure out how this function works for nearly a week now, I've come to the conclusion, its not working as advertised. Part of the problem, is that none of Microsoft's example code uses this function.

There are three ways to use PeerGroupIssueCredentials:

1) PeerGroupIssueCredentials(hGroup, pwzSubjectIdentity, NULL, 0, ppwzInvitation)

In this form, NULL credentials are passed. The information (member data and credentials) stored in the peer database is used. This is a useful way to re-issue a lost invitation.

2) PeerGroupIssueCredentials(hGroup, pwzSubjectIdentity, pCredentialInfo, 0, ppwzInvitation)

In this form, new credentials can be passed in order to generate a new invitation. Typically, this would extend the expiry date of the member or change their role or friendly name. I get a valid invitation. However, when I use this invitation to re-join the group, the updated credentials are not taken.

3) PeerGroupIssueCredentials(hGroup, pwzSubjectIdentity, pCredentialInfo, 1, ppwzInvitation)

Same as 2) except the newly created GMC (invitation) is published to the group and automatically picked up by the member. When the member connects or is connected, I see the PEER_GROUP_EVENT_MEMBER_CHANGED event with changeType=PEER_MEMBER_JOINED. However, again, the updated credentials are not taken.

If anyone has a working example, showing the expiry date of a member being updated correctly using PeerGroupIssueCredentials, I would really appreciate some help.

The other interesting limitation that I came across is that there doesn't appear to be a way to send a change to PEER_MEMBER.pwzAttributes back to the group.

Bug in PEER_RECORD.pszAttributes

2006-01-01T06:12:00.000-08:00

I've been implementing a class to simplify setting and managing the XML attributes associated with a PEER_RECORD. I figured a useful approach to associating attributes is to implement a method that allows you to simply provide an instance of a run-time object, and use reflection to get a list of properties and their current values.

So everything was working great, until I decided to try extracting the attributes of the current PEER_RECORD properties. Whenever I did this and called PeerGraphAddRecord, the error PEER_E_INVALID_ATTRIBUTES. Here is the pszAttribute XML fragement:

<attributes>
<attribute name="Type"
type="string">4d5b2f11-6522-433b-84ef-a298e60757b0</attribute>
<attribute name="ID"
type="string">00000000-0000-0000-0000-000000000000</attribute>
<attribute name="Version" type="int">0</attribute>
<attribute name="CreationTime"
type="date">1600-12-31T17:00:00.0000000-07:00</attribute>
<attribute name="ExpirationTime"
type="date">2006-01-01T07:18:31.0507500-07:00</attribute>
<attribute name="LastModifiedTime"
type="date">1600-12-31T17:00:00.0000000-07:00</attribute>
<attribute name="DataAsStream" type="string">System.IO.MemoryStream</attribute>
<attribute name="DataAsString" type="string">a</attribute>
</attributes>

Turns out, that when I remove the two dates with year 1600, the error no longer occurs.

I've confirmed these are valid XML dates by loading them into a Dataset with a column type of DateTime. They are interpreted and converted correctly.

I'm using Windows XP SP2. Guess I'll report the bug to Microsoft.

Peer Graph - Records

2005-12-29T15:48:00.000-08:00

Posted another article at Code Project: Peer Graph - Records

Windows <3 P2P

2005-12-27T14:57:00.000-08:00

Windows <3 P2P. I think I'll be watching this blog closely. Looks like Vladimir will have some interesting content in the coming months as Windows Collaboration in Vista is completed.

Peer Graph - Exchanging Private Data - The Code Project - C# Programming

2005-12-12T16:19:00.000-08:00

Posted another article at Code Project: Peer Graph - Exchanging Private Data

World Community Grid - Research - FightAIDS@Home

2005-11-23T05:46:00.000-08:00

Now if someone would help this group to write a screen saver for the new XBOX 360's, I'd run it.

http://www.worldcommunitygrid.org/projects_showcase/viewFaahResearch.do

Peer Graph - Peers and Connections

2005-11-17T08:33:00.000-08:00

Posted another article over at Code Project: Peer Graph - Peers and Connections.

Blogging via Peer-to-Peer

2005-11-17T05:06:00.000-08:00

I've often wondered if peer-to-peer would be a good solution for blogging.

Given an application that can generate and maintain an RSS formatted XML file, it should be possible to publish its existence in a peer-to-peer network. I'm not suggesting adding a record to the graph, but rather the node's precense in a common graph would allow searching. The node would also need to register a unique, static name in the PNRP in order for others to be able to find the node again.

Search requests would be published as records to the graph with a short time-to-live (short enough that it couldn't propagate to all nodes in a large network). Any peer close enough to the originator would see this search request and compare its data to the request.

If there is a match, they could open a direct connection to the originator and send a quick response. Its unclear if this would overload the originator. The results could be arranged for presentation. The originator could then decide if they wanted to look at the full blog of each responder or subscribe for any changes or new blog entries from the responder. The static name in the PNRP is needed in order to allow the originator to contact the responder at a later date (if they available).

Blogging via peer-to-peer would allow anyone from their desktop to start blogging. No need for a web-site and no need for a central search engine.

Opinions are welcomed.

An introduction to Microsoft's Peer-to-Peer Graphing technology

2005-11-09T18:00:00.000-08:00

My article introducing Microsoft's Peer-to-Peer Graphing technology was posted today over at Code Project.

Peer Name Resolution (PNRP) - The Code Project - C# Programming

2005-10-27T13:25:00.000-07:00

My article about PNRP was just posted here on the Code Project web site.

New PNRP Functions

2005-10-18T05:44:00.000-07:00

Windows Vista October CTP contains some new PNRP functions that remove the previous complexity of having to use the underlying WSAxxx functions. Since the Windows SDK won't be updated until Beta 2, here's a guess at what these functions probably do.

PeerPnrpGetCloudInfo - probably returns a PNRPCLOUDINFO structure. Not sure how to Enum clouds though. Equivalent to this.

PeerPnrpGetEndpoint - probably converts a peer name to an endpoint

PeerPnrpRegister, PeerPnrpUnregister - probably registers and unregisters a peer name in the serverless DNS. Equivalent to this and this.

PeerPnrpUpdateRegistration - probably allows info such as address and comment to be updated for a previously registered peer name

PeerPnrpResolve - probably determines if a peer name exists. Equivalent to this.

PeerPnrpStartResolve, PeerPnrpEndResolve - asynchronous version

Windows Vista October CTP (Ultimate Edition)

2005-10-17T21:06:00.000-07:00

Install was very easy, and finally provided drivers for all my hardware.

The Windows Collaboration is still busted due to a missing file (RPCSHIM.DLL) referenced by RPCHTTP.DLL. If anyone knows of a quick fix, drop me a comment.

A quick check using dependency walker shows that this build has all the good stuff; new PeerCollab API's and some new Pnrp helper API's. Can't wait for an updated SDK header file to get these exposed to managed code.

Overall, Explorer is a little buggier, but the UI is looking much better.

Keep up the good work Microsoft.

PeerPnrpToDnsName and PeerDnsToPnrpName

2005-10-15T12:06:00.000-07:00

In case anyone is interested, the C# DllImports are below...

[DllImport("pnrpnsp.dll", CharSet=CharSet.Unicode)]internal static extern int PeerPnrpToDnsName(string pwszPnrpNameStr, System.Text.StringBuilder pwszDnsNameStr, ref int pcchDnsName);

[DllImport("pnrpnsp.dll", CharSet=CharSet.Unicode)]
internal static extern int PeerDnsToPnrpName(string pwszDnsNameStr, System.Text.StringBuilder pwszPnrpNameStr, ref int pcchPnrpName);

Use the following code to call the first function...

int length = 255;
System.Text.StringBuilder DnsName = new System.Text.StringBuilder(length);
int err = PnrpNative.PeerPnrpToDnsName(PnrpName, DnsName, ref length);

In the first case, take any Peer Name, for example, 0.test (zero.test) previously registered to get the equivalent serverless DNS name. In this case, test-p.p0.pnrp.net is returned. Passing this into the second function returnes the original 0.test peer name. Use

netsh p2p pnrp cloud>show names

to see other peer name examples that may be registered on your computer. I'm still not sure what the benefit of getting the DNS name gives me.

What I'd like to know though is what parameters do you need to pass to PNRP lookup to get the equivalent of netsh p2p pnrp cloud> show names list of registered names? If anyone knows, please leave a comment.

Software Development Manager

2005-10-15T06:30:00.000-07:00

You'd think that being a software development manager, I'd have my sleeves rolled up every day churning out code. Actually, its the opposite. Once you become a "manager", you do very little coding. Instead, my job is to plan and think ahead to eliminate as many obstacles and risks to the people who do the real coding. My job is to make sure the development "process" is followed to increase the odds that we deliver what the customer wants with a minimum number of deficiencies as possible (oh! and on schedule and on budget). Its an interesting balancing act.

I've been on vacation this week. With two young children in daycare/pre-school/kindergarten, the bills are high so we don't have much money left to go anywhere. Besides, it was a chance to get a break from work and kids. It has been a excellent opportunity to do some coding...

Thread was being stopped.

2005-10-12T13:40:00.000-07:00

While debugging a test application that is using my managed wrapper for Microsoft's Peer-to-Peer API's, I kept getting the following error: "Thread was being stopped."

A quick search via Google shows that others have had the same problem. I found the answer at the end of this link. Turns out I was watching a listbox control. I removed this from the Watch Window and suddenly the problem went away.

Hope this helps someone.

Tripp Parks's WebLog : Most Annoying API

2005-10-05T05:44:00.000-07:00

Tripp Park posted this message about the most annoying Windows API to use.

All I can say is: " I feel your pain ".

I've been working on implementing the Peer Name Resolution functions from C# via Interop and this one is definitely giving me some trouble. PNRP is the foundation for finding peers via the PeerGraph and PeerGroup API sets.

The following code *does not* appear to work.

CSADDR_INFO csaAddr = new CSADDR_INFO();
PNRPINFO pnrpInfo = new PNRPINFO();
BLOB blPnrpData = new BLOB();
WSAQUERYSET querySet = new WSAQUERYSET();
//
// fill a CSADDR_INFO structure from the address
//
csaAddr.iProtocol = 6; // IPPROTO_TCP
csaAddr.iSocketType = 1; // SOCK_STREAM;
csaAddr.LocalAddr.iSockaddrLength = Marshal.SizeOf(typeof(SOCKADDR_IN6));
SOCKADDR_IN6 address = new SOCKADDR_IN6();
address.sin6_addr = Registration.Address.GetAddressBytes();
csaAddr.LocalAddr.lpSockaddr = Marshal.AllocHGlobal(csaAddr.LocalAddr.iSockaddrLength);
Marshal.StructureToPtr(address, csaAddr.LocalAddr.lpSockaddr, false);
//
// build the WSAQUERYSET required to register
//
pnrpInfo.dwSize = Marshal.SizeOf(typeof(PNRPINFO));
pnrpInfo.dwLifetime = Lifetime;
pnrpInfo.lpwszIdentity = Registration.PeerId;
blPnrpData.cbSize = Marshal.SizeOf(typeof(PNRPINFO));
blPnrpData.pBlobData = Marshal.AllocHGlobal(blPnrpData.cbSize);
Marshal.StructureToPtr(pnrpInfo, blPnrpData.pBlobData, false);
querySet.dwSize = Marshal.SizeOf(typeof(WSAQUERYSET));
querySet.dwNameSpace = 38; // NS_PNRPNAME
querySet.dwNumberOfCsAddrs = 1; // one address

querySet.lpServiceClassId = Marshal.AllocHGlobal(Marshal.SizeOf(typeof(Guid)));
Marshal.StructureToPtr(SVCID_PNRPNAMEV1, querySet.lpServiceClassId, false);

querySet.lpszServiceInstanceName = Registration.Name;
querySet.lpszContext = Registration.CloudName;
querySet.lpszComment = Registration.Comment;

querySet.lpcsaBuffer = Marshal.AllocHGlobal(Marshal.SizeOf(typeof(CSADDR_INFO)));
Marshal.StructureToPtr(csaAddr, querySet.lpcsaBuffer, false);

querySet.lpBlob = Marshal.AllocHGlobal(Marshal.SizeOf(typeof(BLOB)));
Marshal.StructureToPtr(blPnrpData, querySet.lpBlob, false);

IntPtr qryptr = Marshal.AllocHGlobal(Marshal.SizeOf(typeof(WSAQUERYSET)));
Marshal.StructureToPtr(querySet, qryptr, false);

uint hr = PnrpNative.WSASetService(qryptr, WSAESETSERVICEOP.Register, 0);
if (hr != 0) throw new System.Net.Sockets.SocketException((int)hr);

Here are the structure definitions:

[StructLayout(LayoutKind.Sequential)]
internal struct SOCKET_ADDRESS
{
public IntPtr lpSockaddr; // LPSOCKADDR
public int iSockaddrLength;
};
[StructLayout(LayoutKind.Sequential)]
internal struct CSADDR_INFO
{
public SOCKET_ADDRESS LocalAddr;
public SOCKET_ADDRESS RemoteAddr;
public int iSocketType;
public int iProtocol;
};
[StructLayout(LayoutKind.Sequential)]
internal struct BLOB
{
public int cbSize;
public IntPtr pBlobData;
}
[StructLayout(LayoutKind.Sequential, CharSet=CharSet.Unicode)]
internal struct WSAQUERYSET
{
public int dwSize;
public string lpszServiceInstanceName;
public IntPtr lpServiceClassId; // LPGUID
public IntPtr lpVersion; // LPWSAVERSION
public string lpszComment;
public int dwNameSpace;
public IntPtr lpNSProviderId; // LPGUID
public string lpszContext;
public int dwNumberOfProtocols;
public IntPtr lpafpProtocols; // LPAFPROTOCOLS
public IntPtr lpszQueryString; // can be NULL
public int dwNumberOfCsAddrs;
public IntPtr lpcsaBuffer; // LPCSADDR_INFO
public int dwOutputFlags;
public IntPtr lpBlob; // LPBLOB
};

[StructLayout(LayoutKind.Sequential, CharSet=CharSet.Unicode)]
internal struct PNRPINFO
{
public int dwSize;
public string lpwszIdentity;
public int nMaxResolve;
public int dwTimeout;
public int dwLifetime;
public PNRP_RESOLVE_CRITERIA enResolveCriteria;
public int dwFlags;
public SOCKET_ADDRESS saHint;
public PNRP_REGISTERED_ID_STATE enNameState;
}

If anyone get's this working, please share...

PeerCollabEnumCapabilities

2005-10-01T08:16:00.000-07:00

Why does PeerCollabEnumCapabilities return "The parameter is incorrect" when I pass the PEER_ENDPOINT part of a PEER_ENDPOINT_NEAR_ME data structure. Does this function allow enumerating the capabilities of a endpoint near me that isn't in my list of contacts?

Below is the managed definition for this function:

[DllImport("p2p.dll", PreserveSig=true)]
internal static extern uint PeerCollabEnumCapabilities(IntPtr pcContact, IntPtr pcEndpoint, IntPtr pCapabilityId, ref IntPtr phPeerEnum);

Since some parameters can be NULL, I'm using IntPtr and having to Marshal each data structure. The structure definition for a PEER_ENDPOINT is:

[StructLayout(LayoutKind.Sequential, CharSet = CharSet.Unicode)]
internal struct PEER_ENDPOINT
{
public PEER_ADDRESS address;
[MarshalAs(UnmanagedType.LPWStr)] public String pwzEndpointName;
};

[StructLayout(LayoutKind.Sequential)]
internal struct PEER_ADDRESS
{
public uint dwSize;
public SOCKADDR_IN6 sin6;
};

[Serializable, StructLayout(LayoutKind.Sequential)]
internal struct SOCKADDR_IN6
{
public short sin6_family;
public ushort sin6_port;
public uint sin6_flowinfo;
[MarshalAs(UnmanagedType.ByValArray, SizeConst=0x10)]
public byte[] sin6_addr;
public uint sin6_scope_id;
};

I'm calling this function in the following way...

IntPtr conptr = IntPtr.Zero;
if (contact != null)
{
PEER_CONTACT ncon = contact.Convert();
conptr = Marshal.AllocHGlobal(Marshal.SizeOf(typeof(PEER_CONTACT)));
Marshal.StructureToPtr(ncon, conptr, true);
}
IntPtr epptr = IntPtr.Zero;
if (endpoint != null)
{
PEER_ENDPOINT nep = endpoint.Convert();
epptr = Marshal.AllocHGlobal(Marshal.SizeOf(typeof(PEER_ENDPOINT)));
Marshal.StructureToPtr(nep, epptr, true);
}
IntPtr capptr = IntPtr.Zero;
result = PeerCollabNative.PeerCollabEnumCapabilities(conptr, epptr, capptr, ref hPeerEnum);

Any help is appreciated.

Problems Enumerating EndPoints

2005-09-28T07:02:00.000-07:00

I'm trying to put together a demo application that uses all the capabilities of the new PeerCollab Managed Wrapper. However, enumerating endpoints for a given contact is giving me problems.

When I call PeerCollabEnumEndpoints passing in what appears to be valid PEER_CONTACT info, I get an E_INVALIDARG result. At first, I was trying to pass in contact info for a PEER_NEAR_ME. Figuring, maybe the contact needs to be added to my list of contacts, I did this, but the same error occurs.

The defintion of PEER_CONTACT works for all the other API calls, so I don't think its the problem.

[StructLayout(LayoutKind.Sequential, CharSet = CharSet.Unicode)]
internal struct PEER_CONTACT
{
[MarshalAs(UnmanagedType.LPWStr)] public String pwzPeerName;
[MarshalAs(UnmanagedType.LPWStr)] public String pwzFriendlyName;
public int fWatch;
public int WatcherPermissions;
};

The API is the following:

HRESULT WINAPI PeerCollabEnumEndpoints(
IN const PCPEER_CONTACT pcContact,
OUT HPEERENUM * phPeerEnum);

My DllImport definition is:

[DllImport("p2p.dll", PreserveSig=true)]
internal static extern uint PeerCollabEnumEndpoints(ref PEER_CONTACT pcContact, ref IntPtr phPeerEnum);

Yet, when I pass the same PEER_CONTACT info to PeerCollabDeleteContact, there is not error.

I'm trying to enumerate the list of endpoints in order to send an invitation.

Any help is appreciated.

Finished Managed PeerCollab Wrapper

2005-09-26T00:04:00.000-07:00

I finally finished implementing the last PeerCollab API function.

The whole wrapper is implemented in C# using DllImport's and InteropServices. I've managed to verify that most functions work correctly. Once I've verified all functions work correctly, I'll probably refactor the classes a little bit and create a custom extension to the My namespace.

I believe need a second Windows Vista computer in order to see another contact besides myself and to monitor changes. I'm not sure why if I Sign-In to the Internet, I don't see other contacts. Is there some port I'm supposed to open on my network firewall?

If anyone knows of an easy way to create a second contact using only one computer, that would be helpful.

PeerGetNextItem Trick

2005-09-24T07:01:00.000-07:00

I'm wrapping the PeerCollab SDK using C#/DllImport.

I was struggleing with PeerGetNextItem returning garbage data until I finally realized its was returning an array of pointers.

HRESULT WINAPI PeerGraphGetNextItem(
IN HPEERENUM hPeerEnum,
IN OUT PULONG pCount,
OUT PVOID * ppvItems);

[DllImport("p2p.dll", PreserveSig=true)]
internal static extern uint PeerGetNextItem(IntPtr hPeerEnum, ref uint count, ref IntPtr ppItems);

To call this function and extract the data, you'll need to do the following...

uint ulItem = 1;
IntPtr capptr = IntPtr.Zero;
uint result = PeerCollabNative.PeerGetNextItem(hPeerEnum, ref ulItem, ref capptr );

The trick is to marshal the first item in the array as a pointer before marshalling the type...

IntPtr itemptr = Marshal.ReadIntPtr(capptr);
PEER_CAPABILITY ncap = (PEER_CAPABILITY)Marshal.PtrToStructure(itemptr, typeof(PEER_CAPABILITY));

Hope this helps someone.

Microsoft Peer-to-Peer Blog Links

2005-09-16T07:00:00.000-07:00

The following links are people at Microsoft working on the Peer-to-Peer technology and gave recent talks at Microsoft's PDC 2005:

Ravi Rao's blog

Noah Horton's WebBlog

Tripp Parks's WebLog

Peer Collaboration Infrastructure

2005-09-13T02:36:00.000-07:00

I've started to investigate the new PeerCollab* methods included in the Windows Vista version of the Platform SDK. So far the documentation isn't really good. The best, but limited source of information is Tripp Parke's blog (http://blogs.msdn.com/tparks/default.aspx)

The SDK documentation is confusing. The term's Peer, Peer Application, Contact and Local Peer are used interchangable.

I'm working on a Managed C++ wrapper for the API's to simplify using this functionality from managed code. The problem is, I'm not much of a C++ programmer, so it slow going.

The other thing I've noticed is that after calling the PeerCollabSignIn method, a Collaboration Host icon appears in the system tray. A p2phost.exe appears in the task manager. I'm not sure what the purpose of this is yet.

Hopefully more inforamtion will be released at next weeks PDC. I have lots of ideas for some great peer applications if I can just get the darn API's to work.