YCC Trainer is designed to teach the logic needed to make your own Yahoo! Messenger client. YCC Trainer is geared towards programmers with little to moderate experience and an understanding of the .NET languages. YCC Trainer is written in Visual Basic .NET 2005 and is part of a larger project at Yahoo! Coder's Cookbook (www.ycoderscookbook.com) intended to teach you everything you need to know about the Yahoo! Messenger protocol. The Yahoo! Messenger protocol version used by YCC Trainer is 15.
YCC Trainer Program Structure
YCC Trainer currently consists of two different projects, the front end GUI and the backend protocol engine. The backend is designed to be separated from the GUI and used for any number of tasks. Since the goal of YCC Trainer is to show how the Yahoo! Messenger protocol works, I will primarily focus on the backend called
YCC_YMSG_Functions consists of four modules,
modSockets. The only module that will need to be accessed is modUser as this is the place that all state data, function calls, and events reside.
All high level communication within
YCC_YMSG_Functions is contained in a structure called
uPacket contains all the header information and payload in an easy to access structure without having to manually parse the information. The process for converting a packet to raw byte data and vice versa is contained in
modYFunctions. When sending a YMSG message you should call
modYFunctions.PacketToByte and when receiving a YMSG message you should convert it to a
uPacket by calling
modYFunctions.ByteToPacket. The third module,
modByteFunctions, holds methods for byte operations such as byte concatenation, which is used throughout
modSockets is the network facing module that converts the byte data into an asynchronous Windows API socket.
Because communications within the Yahoo! Messenger Protocol is asynchronous, data can be sent and received independently and at any time. To send data simply call the associated method in
modUsers. Receiving data is more complicated but is handled by the
socket_receive handles all of the special cases that a YMSG packet can contain and
modUser_ProcessPacket takes action on a particular YMSG service.
Creating a GUI
The first step in creating a front end to
modUser is to create a new instance of
YCC_YMSG_Functions. After this has been done, call
modUser.Login. In this case
Login can be considered the
New function because it initializes your instance of
YCC_YMSG_Functions and makes it ready to become fully operational. The
Login function is also special because it kicks off the packet sequence needed to validate a user against the Yahoo! servers. Once the
AuthResp packet has been correctly sent, you can consider your user to be logged onto Yahoo!
Dim yUser As New YCC_YMSG_Functions.modUser
Dim UserData As New YCC_YMSG_Functions.modUser.uUserData
Dim ServerData As New YCC_YMSG_Functions.modUser.uServerData
_YUser = yUser
AddHandler yUser.PacketRecieved, AddressOf debug.modUser_PacketRecieved
AddHandler yUser.PacketSent, AddressOf debug.modUser_PacketSent
AddHandler yUser.LoginFail, AddressOf yUser_LoginFail
AddHandler yUser.NewMail, AddressOf yUser_NewMail
AddHandler yUser.BuddyListUpdate, AddressOf yUser_BuddyListUpdate
AddHandler yUser.ErrorMessage, AddressOf yUser_ErrorMessage
AddHandler yUser.MessageRecieve, AddressOf yUser_MessageRecieve
AddHandler yUser.NotifyRecieve, AddressOf yUser_NotifyRecieve
While you are creating a new instance of
yUser you should also add handlers for the many
modUser events that can be triggered. Some of these include
YCC Trainer and many other useful programs are housed at Yahoo! Coder's Cookbook (http://ycoderscookbook.com). http://ycoderscookbook.com/YCC_Trainer.htm is the main page for YCC Trainer and a forum is located at http://ycoderscookbook.com/forums. Also at Yahoo! Coder's Cookbook is a full tutorial section explaining much of the Yahoo! Messenger protocol, frequently updated blog, other code samples for Messenger, and much more.
- It will now fully logon. A programming error during the
AuthResp did not properly process the response challenge strings
- Uses YMSG protocol version 15
- New program structure. The high level unit of data is now the
- Multiple YMSG packets within a TCP packet can be handled
- A YMSG message spanning multiple TCP packets can be handled
- Buddy list properly implemented
- Separate ignore list
- Invisible logon
- Basic message handling and notify messages
- A few experimental procedures. Nothing interesting to report yet
- Much more but these are the major fixes
- For now the debug window should be considered broken. It does its very basic job but I have a lot of work to do on the presentation. I have also implemented a custom data structure for the queue. The default size is 25 and I have not tested it over this limit. If it crashes after 25 sent or received messages then this is mostly likely the culprit.
- Implement custom packet maker
- Ability to update the buddy list status
- Add, accept, or remove buddies
- There is a bug during log off. Apparently instead of YMSG, the server sends ****
I am the webmaster for the Yahoo! Coder’s Cookbook located at http://ycoderscookbook.com. At the Yahoo! Coder’s Cookbook (YCC) I have a blog (http://ycoderscookbook.com/blog/), forum (http://ycoderscookbook.com/forums/), Yahoo! Messenger protocol tutorials (http://ycoderscookbook.com/tutorials/index.html) and several programs (http://ycoderscookbook.com/code/index.html). The most notable programs are YCC Yahoo! Bot Maker (http://ycoderscookbook.com/code/YCC_Yahoo_Bot_Maker.html) which is a Yahoo! account creation tool, YCC Cam Cap (http://ycoderscookbook.com/code/YCC_Cam_Cap.html) which automatically captures Yahoo! webcam windows, and YCC Trainer (http://ycoderscookbook.com/code/YCC_Trainer.html) which is a basic primer for learning the Yahoo! Messenger protocol, YMSG. I also offer developer services (http://ycoderscookbook.com/donations/index.html) for those wishing for their very own Yahoo! tool but do not have the time or expertise.