1 #include "Lobby2Message.h"
2 #include "Lobby2Client.h"
3
4 using namespace RakNet;
5
6 unsigned char Lobby2Callbacks::nextCallbackId=0;
7
MessageResult(Platform_Startup * message)8 void Lobby2Callbacks::MessageResult(Platform_Startup *message) {ExecuteDefaultResult(message);}
MessageResult(Platform_Shutdown * message)9 void Lobby2Callbacks::MessageResult(Platform_Shutdown *message) {ExecuteDefaultResult(message);}
MessageResult(System_CreateDatabase * message)10 void Lobby2Callbacks::MessageResult(System_CreateDatabase *message) {ExecuteDefaultResult(message);}
MessageResult(System_DestroyDatabase * message)11 void Lobby2Callbacks::MessageResult(System_DestroyDatabase *message) {ExecuteDefaultResult(message);}
MessageResult(System_CreateTitle * message)12 void Lobby2Callbacks::MessageResult(System_CreateTitle *message) {ExecuteDefaultResult(message);}
MessageResult(System_DestroyTitle * message)13 void Lobby2Callbacks::MessageResult(System_DestroyTitle *message) {ExecuteDefaultResult(message);}
MessageResult(System_GetTitleRequiredAge * message)14 void Lobby2Callbacks::MessageResult(System_GetTitleRequiredAge *message) {ExecuteDefaultResult(message);}
MessageResult(System_GetTitleBinaryData * message)15 void Lobby2Callbacks::MessageResult(System_GetTitleBinaryData *message) {ExecuteDefaultResult(message);}
MessageResult(System_RegisterProfanity * message)16 void Lobby2Callbacks::MessageResult(System_RegisterProfanity *message) {ExecuteDefaultResult(message);}
MessageResult(System_BanUser * message)17 void Lobby2Callbacks::MessageResult(System_BanUser *message) {ExecuteDefaultResult(message);}
MessageResult(System_UnbanUser * message)18 void Lobby2Callbacks::MessageResult(System_UnbanUser *message) {ExecuteDefaultResult(message);}
MessageResult(CDKey_Add * message)19 void Lobby2Callbacks::MessageResult(CDKey_Add *message) {ExecuteDefaultResult(message);}
MessageResult(CDKey_GetStatus * message)20 void Lobby2Callbacks::MessageResult(CDKey_GetStatus *message) {ExecuteDefaultResult(message);}
MessageResult(CDKey_Use * message)21 void Lobby2Callbacks::MessageResult(CDKey_Use *message) {ExecuteDefaultResult(message);}
MessageResult(CDKey_FlagStolen * message)22 void Lobby2Callbacks::MessageResult(CDKey_FlagStolen *message) {ExecuteDefaultResult(message);}
MessageResult(Client_Login * message)23 void Lobby2Callbacks::MessageResult(Client_Login *message) {ExecuteDefaultResult(message);}
MessageResult(Client_Logoff * message)24 void Lobby2Callbacks::MessageResult(Client_Logoff *message) {ExecuteDefaultResult(message);}
MessageResult(Client_RegisterAccount * message)25 void Lobby2Callbacks::MessageResult(Client_RegisterAccount *message) {ExecuteDefaultResult(message);}
MessageResult(System_SetEmailAddressValidated * message)26 void Lobby2Callbacks::MessageResult(System_SetEmailAddressValidated *message) {ExecuteDefaultResult(message);}
MessageResult(Client_ValidateHandle * message)27 void Lobby2Callbacks::MessageResult(Client_ValidateHandle *message) {ExecuteDefaultResult(message);}
MessageResult(System_DeleteAccount * message)28 void Lobby2Callbacks::MessageResult(System_DeleteAccount *message) {ExecuteDefaultResult(message);}
MessageResult(System_PruneAccounts * message)29 void Lobby2Callbacks::MessageResult(System_PruneAccounts *message) {ExecuteDefaultResult(message);}
MessageResult(Client_GetEmailAddress * message)30 void Lobby2Callbacks::MessageResult(Client_GetEmailAddress *message) {ExecuteDefaultResult(message);}
MessageResult(Client_GetPasswordRecoveryQuestionByHandle * message)31 void Lobby2Callbacks::MessageResult(Client_GetPasswordRecoveryQuestionByHandle *message) {ExecuteDefaultResult(message);}
MessageResult(Client_GetPasswordByPasswordRecoveryAnswer * message)32 void Lobby2Callbacks::MessageResult(Client_GetPasswordByPasswordRecoveryAnswer *message) {ExecuteDefaultResult(message);}
MessageResult(Client_ChangeHandle * message)33 void Lobby2Callbacks::MessageResult(Client_ChangeHandle *message) {ExecuteDefaultResult(message);}
MessageResult(Client_UpdateAccount * message)34 void Lobby2Callbacks::MessageResult(Client_UpdateAccount *message) {ExecuteDefaultResult(message);}
MessageResult(Client_GetAccountDetails * message)35 void Lobby2Callbacks::MessageResult(Client_GetAccountDetails *message) {ExecuteDefaultResult(message);}
MessageResult(Client_StartIgnore * message)36 void Lobby2Callbacks::MessageResult(Client_StartIgnore *message) {ExecuteDefaultResult(message);}
MessageResult(Client_StopIgnore * message)37 void Lobby2Callbacks::MessageResult(Client_StopIgnore *message) {ExecuteDefaultResult(message);}
MessageResult(Client_GetIgnoreList * message)38 void Lobby2Callbacks::MessageResult(Client_GetIgnoreList *message) {ExecuteDefaultResult(message);}
MessageResult(Client_PerTitleIntegerStorage * message)39 void Lobby2Callbacks::MessageResult(Client_PerTitleIntegerStorage *message) {ExecuteDefaultResult(message);}
MessageResult(Client_PerTitleBinaryStorage * message)40 void Lobby2Callbacks::MessageResult(Client_PerTitleBinaryStorage *message) {ExecuteDefaultResult(message);}
MessageResult(Client_SetPresence * message)41 void Lobby2Callbacks::MessageResult(Client_SetPresence *message) {ExecuteDefaultResult(message);}
MessageResult(Client_GetPresence * message)42 void Lobby2Callbacks::MessageResult(Client_GetPresence *message) {ExecuteDefaultResult(message);}
MessageResult(Friends_SendInvite * message)43 void Lobby2Callbacks::MessageResult(Friends_SendInvite *message) {ExecuteDefaultResult(message);}
MessageResult(Friends_AcceptInvite * message)44 void Lobby2Callbacks::MessageResult(Friends_AcceptInvite *message) {ExecuteDefaultResult(message);}
MessageResult(Friends_RejectInvite * message)45 void Lobby2Callbacks::MessageResult(Friends_RejectInvite *message) {ExecuteDefaultResult(message);}
MessageResult(Friends_GetInvites * message)46 void Lobby2Callbacks::MessageResult(Friends_GetInvites *message) {ExecuteDefaultResult(message);}
MessageResult(Friends_GetFriends * message)47 void Lobby2Callbacks::MessageResult(Friends_GetFriends *message) {ExecuteDefaultResult(message);}
MessageResult(Friends_Remove * message)48 void Lobby2Callbacks::MessageResult(Friends_Remove *message) {ExecuteDefaultResult(message);}
MessageResult(BookmarkedUsers_Add * message)49 void Lobby2Callbacks::MessageResult(BookmarkedUsers_Add *message) {ExecuteDefaultResult(message);}
MessageResult(BookmarkedUsers_Remove * message)50 void Lobby2Callbacks::MessageResult(BookmarkedUsers_Remove *message) {ExecuteDefaultResult(message);}
MessageResult(BookmarkedUsers_Get * message)51 void Lobby2Callbacks::MessageResult(BookmarkedUsers_Get *message) {ExecuteDefaultResult(message);}
MessageResult(Emails_Send * message)52 void Lobby2Callbacks::MessageResult(Emails_Send *message) {ExecuteDefaultResult(message);}
MessageResult(Emails_Get * message)53 void Lobby2Callbacks::MessageResult(Emails_Get *message) {ExecuteDefaultResult(message);}
MessageResult(Emails_Delete * message)54 void Lobby2Callbacks::MessageResult(Emails_Delete *message) {ExecuteDefaultResult(message);}
MessageResult(Emails_SetStatus * message)55 void Lobby2Callbacks::MessageResult(Emails_SetStatus *message) {ExecuteDefaultResult(message);}
MessageResult(Ranking_SubmitMatch * message)56 void Lobby2Callbacks::MessageResult(Ranking_SubmitMatch *message) {ExecuteDefaultResult(message);}
MessageResult(Ranking_GetMatches * message)57 void Lobby2Callbacks::MessageResult(Ranking_GetMatches *message) {ExecuteDefaultResult(message);}
MessageResult(Ranking_GetMatchBinaryData * message)58 void Lobby2Callbacks::MessageResult(Ranking_GetMatchBinaryData *message) {ExecuteDefaultResult(message);}
MessageResult(Ranking_GetTotalScore * message)59 void Lobby2Callbacks::MessageResult(Ranking_GetTotalScore *message) {ExecuteDefaultResult(message);}
MessageResult(Ranking_WipeScoresForPlayer * message)60 void Lobby2Callbacks::MessageResult(Ranking_WipeScoresForPlayer *message) {ExecuteDefaultResult(message);}
MessageResult(Ranking_WipeMatches * message)61 void Lobby2Callbacks::MessageResult(Ranking_WipeMatches *message) {ExecuteDefaultResult(message);}
MessageResult(Ranking_PruneMatches * message)62 void Lobby2Callbacks::MessageResult(Ranking_PruneMatches *message) {ExecuteDefaultResult(message);}
MessageResult(Ranking_UpdateRating * message)63 void Lobby2Callbacks::MessageResult(Ranking_UpdateRating *message) {ExecuteDefaultResult(message);}
MessageResult(Ranking_WipeRatings * message)64 void Lobby2Callbacks::MessageResult(Ranking_WipeRatings *message) {ExecuteDefaultResult(message);}
MessageResult(Ranking_GetRating * message)65 void Lobby2Callbacks::MessageResult(Ranking_GetRating *message) {ExecuteDefaultResult(message);}
MessageResult(Clans_Create * message)66 void Lobby2Callbacks::MessageResult(Clans_Create *message) {ExecuteDefaultResult(message);}
MessageResult(Clans_SetProperties * message)67 void Lobby2Callbacks::MessageResult(Clans_SetProperties *message) {ExecuteDefaultResult(message);}
MessageResult(Clans_GetProperties * message)68 void Lobby2Callbacks::MessageResult(Clans_GetProperties *message) {ExecuteDefaultResult(message);}
MessageResult(Clans_SetMyMemberProperties * message)69 void Lobby2Callbacks::MessageResult(Clans_SetMyMemberProperties *message) {ExecuteDefaultResult(message);}
MessageResult(Clans_GrantLeader * message)70 void Lobby2Callbacks::MessageResult(Clans_GrantLeader *message) {ExecuteDefaultResult(message);}
MessageResult(Clans_SetSubleaderStatus * message)71 void Lobby2Callbacks::MessageResult(Clans_SetSubleaderStatus *message) {ExecuteDefaultResult(message);}
MessageResult(Clans_SetMemberRank * message)72 void Lobby2Callbacks::MessageResult(Clans_SetMemberRank *message) {ExecuteDefaultResult(message);}
MessageResult(Clans_GetMemberProperties * message)73 void Lobby2Callbacks::MessageResult(Clans_GetMemberProperties *message) {ExecuteDefaultResult(message);}
MessageResult(Clans_ChangeHandle * message)74 void Lobby2Callbacks::MessageResult(Clans_ChangeHandle *message) {ExecuteDefaultResult(message);}
MessageResult(Clans_Leave * message)75 void Lobby2Callbacks::MessageResult(Clans_Leave *message) {ExecuteDefaultResult(message);}
MessageResult(Clans_Get * message)76 void Lobby2Callbacks::MessageResult(Clans_Get *message) {ExecuteDefaultResult(message);}
MessageResult(Clans_SendJoinInvitation * message)77 void Lobby2Callbacks::MessageResult(Clans_SendJoinInvitation *message) {ExecuteDefaultResult(message);}
MessageResult(Clans_WithdrawJoinInvitation * message)78 void Lobby2Callbacks::MessageResult(Clans_WithdrawJoinInvitation *message) {ExecuteDefaultResult(message);}
MessageResult(Clans_AcceptJoinInvitation * message)79 void Lobby2Callbacks::MessageResult(Clans_AcceptJoinInvitation *message) {ExecuteDefaultResult(message);}
MessageResult(Clans_RejectJoinInvitation * message)80 void Lobby2Callbacks::MessageResult(Clans_RejectJoinInvitation *message) {ExecuteDefaultResult(message);}
MessageResult(Clans_DownloadInvitationList * message)81 void Lobby2Callbacks::MessageResult(Clans_DownloadInvitationList *message) {ExecuteDefaultResult(message);}
MessageResult(Clans_SendJoinRequest * message)82 void Lobby2Callbacks::MessageResult(Clans_SendJoinRequest *message) {ExecuteDefaultResult(message);}
MessageResult(Clans_WithdrawJoinRequest * message)83 void Lobby2Callbacks::MessageResult(Clans_WithdrawJoinRequest *message) {ExecuteDefaultResult(message);}
MessageResult(Clans_AcceptJoinRequest * message)84 void Lobby2Callbacks::MessageResult(Clans_AcceptJoinRequest *message) {ExecuteDefaultResult(message);}
MessageResult(Clans_RejectJoinRequest * message)85 void Lobby2Callbacks::MessageResult(Clans_RejectJoinRequest *message) {ExecuteDefaultResult(message);}
MessageResult(Clans_DownloadRequestList * message)86 void Lobby2Callbacks::MessageResult(Clans_DownloadRequestList *message) {ExecuteDefaultResult(message);}
MessageResult(Clans_KickAndBlacklistUser * message)87 void Lobby2Callbacks::MessageResult(Clans_KickAndBlacklistUser *message) {ExecuteDefaultResult(message);}
MessageResult(Clans_UnblacklistUser * message)88 void Lobby2Callbacks::MessageResult(Clans_UnblacklistUser *message) {ExecuteDefaultResult(message);}
MessageResult(Clans_GetBlacklist * message)89 void Lobby2Callbacks::MessageResult(Clans_GetBlacklist *message) {ExecuteDefaultResult(message);}
MessageResult(Clans_GetMembers * message)90 void Lobby2Callbacks::MessageResult(Clans_GetMembers *message) {ExecuteDefaultResult(message);}
MessageResult(Clans_GetList * message)91 void Lobby2Callbacks::MessageResult(Clans_GetList *message) {ExecuteDefaultResult(message);}
MessageResult(Clans_CreateBoard * message)92 void Lobby2Callbacks::MessageResult(Clans_CreateBoard *message) {ExecuteDefaultResult(message);}
MessageResult(Clans_DestroyBoard * message)93 void Lobby2Callbacks::MessageResult(Clans_DestroyBoard *message) {ExecuteDefaultResult(message);}
MessageResult(Clans_CreateNewTopic * message)94 void Lobby2Callbacks::MessageResult(Clans_CreateNewTopic *message) {ExecuteDefaultResult(message);}
MessageResult(Clans_ReplyToTopic * message)95 void Lobby2Callbacks::MessageResult(Clans_ReplyToTopic *message) {ExecuteDefaultResult(message);}
MessageResult(Clans_RemovePost * message)96 void Lobby2Callbacks::MessageResult(Clans_RemovePost *message) {ExecuteDefaultResult(message);}
MessageResult(Clans_GetBoards * message)97 void Lobby2Callbacks::MessageResult(Clans_GetBoards *message) {ExecuteDefaultResult(message);}
MessageResult(Clans_GetTopics * message)98 void Lobby2Callbacks::MessageResult(Clans_GetTopics *message) {ExecuteDefaultResult(message);}
MessageResult(Clans_GetPosts * message)99 void Lobby2Callbacks::MessageResult(Clans_GetPosts *message) {ExecuteDefaultResult(message);}
MessageResult(Console_GetServerStatus * message)100 void Lobby2Callbacks::MessageResult(Console_GetServerStatus *message) {ExecuteDefaultResult(message);}
MessageResult(Console_GetWorldListFromServer * message)101 void Lobby2Callbacks::MessageResult(Console_GetWorldListFromServer *message) {ExecuteDefaultResult(message);}
MessageResult(Console_GetLobbyListFromWorld * message)102 void Lobby2Callbacks::MessageResult(Console_GetLobbyListFromWorld *message) {ExecuteDefaultResult(message);}
MessageResult(Console_JoinLobby * message)103 void Lobby2Callbacks::MessageResult(Console_JoinLobby *message) {ExecuteDefaultResult(message);}
MessageResult(Console_LeaveLobby * message)104 void Lobby2Callbacks::MessageResult(Console_LeaveLobby *message) {ExecuteDefaultResult(message);}
MessageResult(Console_SendLobbyChatMessage * message)105 void Lobby2Callbacks::MessageResult(Console_SendLobbyChatMessage *message) {ExecuteDefaultResult(message);}
MessageResult(Console_SearchRooms * message)106 void Lobby2Callbacks::MessageResult(Console_SearchRooms *message) {ExecuteDefaultResult(message);}
MessageResult(Console_GetRoomDetails * message)107 void Lobby2Callbacks::MessageResult(Console_GetRoomDetails *message) {ExecuteDefaultResult(message);}
MessageResult(Console_GetLobbyMemberData * message)108 void Lobby2Callbacks::MessageResult(Console_GetLobbyMemberData *message) {ExecuteDefaultResult(message);}
MessageResult(Console_CreateRoom * message)109 void Lobby2Callbacks::MessageResult(Console_CreateRoom *message) {ExecuteDefaultResult(message);}
MessageResult(Console_SetRoomSearchProperties * message)110 void Lobby2Callbacks::MessageResult(Console_SetRoomSearchProperties *message) {ExecuteDefaultResult(message);}
MessageResult(Console_UpdateRoomParameters * message)111 void Lobby2Callbacks::MessageResult(Console_UpdateRoomParameters *message) {ExecuteDefaultResult(message);}
MessageResult(Console_JoinRoom * message)112 void Lobby2Callbacks::MessageResult(Console_JoinRoom *message) {ExecuteDefaultResult(message);}
MessageResult(Console_LeaveRoom * message)113 void Lobby2Callbacks::MessageResult(Console_LeaveRoom *message) {ExecuteDefaultResult(message);}
MessageResult(Console_SendLobbyInvitationToRoom * message)114 void Lobby2Callbacks::MessageResult(Console_SendLobbyInvitationToRoom *message) {ExecuteDefaultResult(message);}
MessageResult(Console_SendGUIInvitationToRoom * message)115 void Lobby2Callbacks::MessageResult(Console_SendGUIInvitationToRoom *message) {ExecuteDefaultResult(message);}
MessageResult(Console_SendDataMessageToUser * message)116 void Lobby2Callbacks::MessageResult(Console_SendDataMessageToUser *message) {ExecuteDefaultResult(message);}
MessageResult(Console_SendRoomChatMessage * message)117 void Lobby2Callbacks::MessageResult(Console_SendRoomChatMessage *message) {ExecuteDefaultResult(message);}
MessageResult(Notification_Client_RemoteLogin * message)118 void Lobby2Callbacks::MessageResult(Notification_Client_RemoteLogin *message) {ExecuteDefaultResult(message);}
MessageResult(Notification_Client_IgnoreStatus * message)119 void Lobby2Callbacks::MessageResult(Notification_Client_IgnoreStatus *message) {ExecuteDefaultResult(message);}
MessageResult(Notification_Friends_StatusChange * message)120 void Lobby2Callbacks::MessageResult(Notification_Friends_StatusChange *message) {ExecuteDefaultResult(message);}
MessageResult(Notification_Friends_PresenceUpdate * message)121 void Lobby2Callbacks::MessageResult(Notification_Friends_PresenceUpdate *message) {ExecuteDefaultResult(message);}
MessageResult(Notification_User_ChangedHandle * message)122 void Lobby2Callbacks::MessageResult(Notification_User_ChangedHandle *message) {ExecuteDefaultResult(message);}
MessageResult(Notification_Friends_CreatedClan * message)123 void Lobby2Callbacks::MessageResult(Notification_Friends_CreatedClan *message) {ExecuteDefaultResult(message);}
MessageResult(Notification_Emails_Received * message)124 void Lobby2Callbacks::MessageResult(Notification_Emails_Received *message) {ExecuteDefaultResult(message);}
MessageResult(Notification_Clans_GrantLeader * message)125 void Lobby2Callbacks::MessageResult(Notification_Clans_GrantLeader *message) {ExecuteDefaultResult(message);}
MessageResult(Notification_Clans_SetSubleaderStatus * message)126 void Lobby2Callbacks::MessageResult(Notification_Clans_SetSubleaderStatus *message) {ExecuteDefaultResult(message);}
MessageResult(Notification_Clans_SetMemberRank * message)127 void Lobby2Callbacks::MessageResult(Notification_Clans_SetMemberRank *message) {ExecuteDefaultResult(message);}
MessageResult(Notification_Clans_ChangeHandle * message)128 void Lobby2Callbacks::MessageResult(Notification_Clans_ChangeHandle *message) {ExecuteDefaultResult(message);}
MessageResult(Notification_Clans_Leave * message)129 void Lobby2Callbacks::MessageResult(Notification_Clans_Leave *message) {ExecuteDefaultResult(message);}
MessageResult(Notification_Clans_PendingJoinStatus * message)130 void Lobby2Callbacks::MessageResult(Notification_Clans_PendingJoinStatus *message) {ExecuteDefaultResult(message);}
MessageResult(Notification_Clans_NewClanMember * message)131 void Lobby2Callbacks::MessageResult(Notification_Clans_NewClanMember *message) {ExecuteDefaultResult(message);}
MessageResult(Notification_Clans_KickAndBlacklistUser * message)132 void Lobby2Callbacks::MessageResult(Notification_Clans_KickAndBlacklistUser *message) {ExecuteDefaultResult(message);}
MessageResult(Notification_Clans_UnblacklistUser * message)133 void Lobby2Callbacks::MessageResult(Notification_Clans_UnblacklistUser *message) {ExecuteDefaultResult(message);}
MessageResult(Notification_Clans_Destroyed * message)134 void Lobby2Callbacks::MessageResult(Notification_Clans_Destroyed *message) {ExecuteDefaultResult(message);}
MessageResult(Notification_Console_CableDisconnected * message)135 void Lobby2Callbacks::MessageResult(Notification_Console_CableDisconnected *message) {ExecuteDefaultResult(message);}
MessageResult(Notification_Console_ContextError * message)136 void Lobby2Callbacks::MessageResult(Notification_Console_ContextError *message) {ExecuteDefaultResult(message);}
MessageResult(Notification_Console_MemberJoinedLobby * message)137 void Lobby2Callbacks::MessageResult(Notification_Console_MemberJoinedLobby *message) {ExecuteDefaultResult(message);}
MessageResult(Notification_Console_MemberLeftLobby * message)138 void Lobby2Callbacks::MessageResult(Notification_Console_MemberLeftLobby *message) {ExecuteDefaultResult(message);}
MessageResult(Notification_Console_LobbyDestroyed * message)139 void Lobby2Callbacks::MessageResult(Notification_Console_LobbyDestroyed *message) {ExecuteDefaultResult(message);}
MessageResult(Notification_Console_LobbyMemberDataUpdated * message)140 void Lobby2Callbacks::MessageResult(Notification_Console_LobbyMemberDataUpdated *message) {ExecuteDefaultResult(message);}
MessageResult(Notification_Console_LobbyGotChatMessage * message)141 void Lobby2Callbacks::MessageResult(Notification_Console_LobbyGotChatMessage *message) {ExecuteDefaultResult(message);}
MessageResult(Notification_Console_LobbyGotRoomInvitation * message)142 void Lobby2Callbacks::MessageResult(Notification_Console_LobbyGotRoomInvitation *message) {ExecuteDefaultResult(message);}
MessageResult(Notification_Console_MemberJoinedRoom * message)143 void Lobby2Callbacks::MessageResult(Notification_Console_MemberJoinedRoom *message) {ExecuteDefaultResult(message);}
MessageResult(Notification_Console_MemberLeftRoom * message)144 void Lobby2Callbacks::MessageResult(Notification_Console_MemberLeftRoom *message) {ExecuteDefaultResult(message);}
MessageResult(Notification_Console_KickedOutOfRoom * message)145 void Lobby2Callbacks::MessageResult(Notification_Console_KickedOutOfRoom *message) {ExecuteDefaultResult(message);}
MessageResult(Notification_Console_RoomWasDestroyed * message)146 void Lobby2Callbacks::MessageResult(Notification_Console_RoomWasDestroyed *message) {ExecuteDefaultResult(message);}
MessageResult(Notification_Console_UpdateRoomParameters * message)147 void Lobby2Callbacks::MessageResult(Notification_Console_UpdateRoomParameters *message) {ExecuteDefaultResult(message);}
MessageResult(Notification_Console_RoomOwnerChanged * message)148 void Lobby2Callbacks::MessageResult(Notification_Console_RoomOwnerChanged *message) {ExecuteDefaultResult(message);}
MessageResult(Notification_Console_RoomChatMessage * message)149 void Lobby2Callbacks::MessageResult(Notification_Console_RoomChatMessage *message) {ExecuteDefaultResult(message);}
MessageResult(Notification_Console_RoomMessage * message)150 void Lobby2Callbacks::MessageResult(Notification_Console_RoomMessage *message) {ExecuteDefaultResult(message);}
MessageResult(Notification_Console_RoomMemberConnectivityUpdate * message)151 void Lobby2Callbacks::MessageResult(Notification_Console_RoomMemberConnectivityUpdate *message) {ExecuteDefaultResult(message);}
MessageResult(Notification_Console_ChatEvent * message)152 void Lobby2Callbacks::MessageResult(Notification_Console_ChatEvent *message) {ExecuteDefaultResult(message);}
MessageResult(Notification_Console_MuteListChanged * message)153 void Lobby2Callbacks::MessageResult(Notification_Console_MuteListChanged *message) {ExecuteDefaultResult(message);}
MessageResult(Notification_Console_Local_Users_Changed * message)154 void Lobby2Callbacks::MessageResult(Notification_Console_Local_Users_Changed *message) {ExecuteDefaultResult(message);}
MessageResult(Notification_ReceivedDataMessageFromUser * message)155 void Lobby2Callbacks::MessageResult(Notification_ReceivedDataMessageFromUser *message) {ExecuteDefaultResult(message);}
156
Lobby2Message()157 Lobby2Message::Lobby2Message() {refCount=1; requestId=(unsigned int)-1; callbackId=(unsigned char)-1;
158
159
160
161 }
SerializeBase(bool writeToBitstream,bool serializeOutput,BitStream * bitStream)162 void Lobby2Message::SerializeBase(bool writeToBitstream, bool serializeOutput, BitStream *bitStream)
163 {
164 bitStream->Serialize(writeToBitstream, requestId);
165 bitStream->Serialize(writeToBitstream, callbackId);
166 if (serializeOutput)
167 bitStream->Serialize(writeToBitstream, resultCode);
168 }
Serialize(bool writeToBitstream,bool serializeOutput,BitStream * bitStream)169 void Lobby2Message::Serialize( bool writeToBitstream, bool serializeOutput, BitStream *bitStream ) { SerializeBase(writeToBitstream, serializeOutput, bitStream); }
ValidateBinary(RakNetSmartPtr<BinaryDataBlock> binaryDataBlock)170 bool Lobby2Message::ValidateBinary( RakNetSmartPtr<BinaryDataBlock>binaryDataBlock)
171 {
172 if (binaryDataBlock->binaryDataLength>L2_MAX_BINARY_DATA_LENGTH)
173 {
174 resultCode=L2RC_BINARY_DATA_LENGTH_EXCEEDED;
175 return false;
176 }
177
178 if (binaryDataBlock->binaryDataLength>0 && binaryDataBlock->binaryData==0)
179 {
180 resultCode=L2RC_BINARY_DATA_NULL_POINTER;
181 return false;
182 }
183
184 return true;
185 }
ValidateHandle(RakString * handle)186 bool Lobby2Message::ValidateHandle( RakString *handle )
187 {
188 if (handle->IsEmpty())
189 {
190 resultCode=L2RC_HANDLE_IS_EMPTY;
191 return false;
192 }
193 if (handle->C_String()[0]==' ')
194 {
195 resultCode=L2RC_HANDLE_STARTS_WITH_SPACES;
196 return false;
197 }
198 size_t len = handle->GetLength();
199 if (handle->C_String()[len-1]==' ')
200 {
201 resultCode=L2RC_HANDLE_ENDS_WITH_SPACES;
202 return false;
203 }
204 if (len>50)
205 {
206 resultCode=L2RC_HANDLE_IS_TOO_LONG;
207 return false;
208 }
209 if (len<=2)
210 {
211 resultCode=L2RC_HANDLE_IS_TOO_SHORT;
212 return false;
213 }
214 if (handle->ContainsNonprintableExceptSpaces())
215 {
216 resultCode=L2RC_HANDLE_CONTAINS_NON_PRINTABLE;
217 return false;
218 }
219 if (strstr(handle->C_String(), " ")!=0)
220 {
221 resultCode=L2RC_HANDLE_HAS_CONSECUTIVE_SPACES;
222 return false;
223 }
224 return true;
225 }
ValidateRequiredText(RakString * text)226 bool Lobby2Message::ValidateRequiredText( RakString *text )
227 {
228 if (text->IsEmpty())
229 {
230 resultCode=L2RC_REQUIRED_TEXT_IS_EMPTY;
231 return false;
232 }
233 return true;
234 }
ValidatePassword(RakString * text)235 bool Lobby2Message::ValidatePassword( RakString *text )
236 {
237 if (text->IsEmpty())
238 {
239 resultCode=L2RC_PASSWORD_IS_EMPTY;
240 return false;
241 }
242
243 size_t len = text->GetLength();
244 if (len>50)
245 {
246 resultCode=L2RC_PASSWORD_IS_TOO_LONG;
247 return false;
248 }
249 if (len<4)
250 {
251 resultCode=L2RC_PASSWORD_IS_TOO_SHORT;
252 return false;
253 }
254
255 return true;
256 }
ValidateEmailAddress(RakString * text)257 bool Lobby2Message::ValidateEmailAddress( RakString *text )
258 {
259 if (text->IsEmpty())
260 {
261 resultCode=L2RC_EMAIL_ADDRESS_IS_EMPTY;
262 return false;
263 }
264 if (text->IsEmailAddress()==false)
265 {
266 resultCode=L2RC_EMAIL_ADDRESS_IS_INVALID;
267 return false;
268 }
269 return true;
270 }
PrevalidateInput(void)271 bool Lobby2Message::PrevalidateInput(void) {return true;}
ClientImpl(Lobby2Client * client)272 bool Lobby2Message::ClientImpl( Lobby2Client *client) { (void)client; return true; }
ServerPreDBMemoryImpl(Lobby2Server * server,RakString userHandle)273 bool Lobby2Message::ServerPreDBMemoryImpl( Lobby2Server *server, RakString userHandle ) { (void)server; (void)userHandle; return false; }
ServerPostDBMemoryImpl(Lobby2Server * server,RakString userHandle)274 void Lobby2Message::ServerPostDBMemoryImpl( Lobby2Server *server, RakString userHandle ) { (void)server; (void)userHandle; }
ServerDBImpl(Lobby2ServerCommand * command,void * databaseInterface)275 bool Lobby2Message::ServerDBImpl( Lobby2ServerCommand *command, void *databaseInterface ) { (void)command; (void)databaseInterface; resultCode=L2RC_COUNT; return true; }
276
Serialize(bool writeToBitstream,BitStream * bitStream)277 void CreateAccountParameters::Serialize(bool writeToBitstream, BitStream *bitStream)
278 {
279 bitStream->Serialize(writeToBitstream, firstName);
280 bitStream->Serialize(writeToBitstream, middleName);
281 bitStream->Serialize(writeToBitstream, lastName);
282 bitStream->Serialize(writeToBitstream, race);
283 bitStream->Serialize(writeToBitstream, sex_male);
284 bitStream->Serialize(writeToBitstream, homeAddress1);
285 bitStream->Serialize(writeToBitstream, homeAddress2);
286 bitStream->Serialize(writeToBitstream, homeCity);
287 bitStream->Serialize(writeToBitstream, homeState);
288 bitStream->Serialize(writeToBitstream, homeCountry);
289 bitStream->Serialize(writeToBitstream, homeZipCode);
290 bitStream->Serialize(writeToBitstream, billingAddress1);
291 bitStream->Serialize(writeToBitstream, billingAddress2);
292 bitStream->Serialize(writeToBitstream, billingCity);
293 bitStream->Serialize(writeToBitstream, billingState);
294 bitStream->Serialize(writeToBitstream, billingCountry);
295 bitStream->Serialize(writeToBitstream, billingZipCode);
296 bitStream->Serialize(writeToBitstream, emailAddress);
297 bitStream->Serialize(writeToBitstream, password);
298 bitStream->Serialize(writeToBitstream, passwordRecoveryQuestion);
299 bitStream->Serialize(writeToBitstream, passwordRecoveryAnswer);
300 bitStream->Serialize(writeToBitstream, caption1);
301 bitStream->Serialize(writeToBitstream, caption2);
302 bitStream->Serialize(writeToBitstream, ageInDays);
303 binaryData->Serialize(writeToBitstream,bitStream);
304 }
Serialize(bool writeToBitstream,BitStream * bitStream)305 void BinaryDataBlock::Serialize(bool writeToBitstream, BitStream *bitStream)
306 {
307 bool hasData=binaryData && binaryDataLength>0;
308 bitStream->Serialize(writeToBitstream, hasData);
309 if (hasData==false)
310 return;
311 bitStream->Serialize(writeToBitstream, binaryDataLength);
312 if (writeToBitstream==false)
313 {
314 if (binaryData)
315 rakFree_Ex(binaryData, __FILE__, __LINE__ );
316
317 if (binaryDataLength<=L2_MAX_BINARY_DATA_LENGTH)
318 binaryData = (char*) rakMalloc_Ex(binaryDataLength, __FILE__, __LINE__);
319 else
320 binaryData=0;
321 }
322 if (binaryData)
323 bitStream->Serialize(writeToBitstream, binaryData, binaryDataLength);
324 else if (writeToBitstream==false)
325 bitStream->IgnoreBytes(binaryDataLength);
326 }
Serialize(bool writeToBitstream,BitStream * bitStream)327 void PendingInvite::Serialize(bool writeToBitstream, BitStream *bitStream)
328 {
329 bitStream->Serialize(writeToBitstream, sender);
330 bitStream->Serialize(writeToBitstream, subject);
331 bitStream->Serialize(writeToBitstream, body);
332 binaryData->Serialize(writeToBitstream, bitStream);
333 }
Serialize(bool writeToBitstream,BitStream * bitStream)334 void UsernameAndOnlineStatus::Serialize(bool writeToBitstream, BitStream *bitStream)
335 {
336 bitStream->Serialize(writeToBitstream, handle);
337 bitStream->Serialize(writeToBitstream, isOnline);
338 presence.Serialize(bitStream,writeToBitstream);
339 }
Serialize(bool writeToBitstream,BitStream * bitStream)340 void EmailResult::Serialize(bool writeToBitstream, BitStream *bitStream)
341 {
342 bitStream->Serialize(writeToBitstream, sender);
343 bitStream->Serialize(writeToBitstream, recipient);
344 bitStream->Serialize(writeToBitstream, subject);
345 bitStream->Serialize(writeToBitstream, body);
346 bitStream->Serialize(writeToBitstream, status);
347 bitStream->Serialize(writeToBitstream, wasSendByMe);
348 bitStream->Serialize(writeToBitstream, wasReadByMe);
349 bitStream->Serialize(writeToBitstream, subject);
350 bitStream->Serialize(writeToBitstream, emailID);
351 binaryData->Serialize(writeToBitstream, bitStream);
352 bitStream->Serialize(writeToBitstream, creationDate);
353 }
Serialize(bool writeToBitstream,BitStream * bitStream)354 void MatchParticipant::Serialize(bool writeToBitstream, BitStream *bitStream)
355 {
356 bitStream->Serialize(writeToBitstream, handle);
357 bitStream->Serialize(writeToBitstream, score);
358 }
Serialize(bool writeToBitstream,BitStream * bitStream)359 void SubmittedMatch::Serialize(bool writeToBitstream, BitStream *bitStream)
360 {
361 bitStream->Serialize(writeToBitstream, matchNote);
362 bitStream->Serialize(writeToBitstream, whenSubmittedDate);
363 bitStream->Serialize(writeToBitstream, matchID);
364 binaryData->Serialize(writeToBitstream, bitStream);
365 unsigned short listSize = (unsigned short) matchParticipants.Size();
366 bitStream->SerializeCompressed(writeToBitstream, listSize);
367 for (unsigned int i=0; i < listSize; i++)
368 {
369 MatchParticipant obj;
370 if (writeToBitstream)
371 {
372 matchParticipants[i].Serialize(writeToBitstream, bitStream);
373 }
374 else
375 {
376 obj.Serialize(writeToBitstream, bitStream);
377 matchParticipants.Insert(obj, __FILE__, __LINE__ );
378 }
379 }
380 }
Serialize(bool writeToBitstream,BitStream * bitStream)381 void ClanInfo::Serialize(bool writeToBitstream, BitStream *bitStream)
382 {
383 bitStream->Serialize(writeToBitstream, clanName);
384 bitStream->Serialize(writeToBitstream, description);
385 bitStream->Serialize(writeToBitstream, clanLeader);
386 binaryData->Serialize(writeToBitstream, bitStream);
387 unsigned short listSize = (unsigned short) clanMembersOtherThanLeader.Size();
388 bitStream->SerializeCompressed(writeToBitstream, listSize);
389 for (unsigned int i=0; i < listSize; i++)
390 {
391 RakString obj;
392 if (writeToBitstream)
393 {
394 bitStream->Serialize(writeToBitstream, clanMembersOtherThanLeader[i]);
395 }
396 else
397 {
398 bitStream->Serialize(writeToBitstream, obj);
399 clanMembersOtherThanLeader.Insert(obj, __FILE__, __LINE__ );
400 }
401 }
402 }
Serialize(bool writeToBitstream,BitStream * bitStream)403 void OpenInvite::Serialize(bool writeToBitstream, BitStream *bitStream)
404 {
405 bitStream->Serialize(writeToBitstream, clanHandle);
406 }
Serialize(bool writeToBitstream,BitStream * bitStream)407 void ClanJoinRequest::Serialize(bool writeToBitstream, BitStream *bitStream)
408 {
409 bitStream->Serialize(writeToBitstream, targetClan);
410 bitStream->Serialize(writeToBitstream, dateSent);
411 bitStream->Serialize(writeToBitstream, joinRequestSender);
412 }
Serialize(bool writeToBitstream,BitStream * bitStream)413 void ClanJoinInvite::Serialize(bool writeToBitstream, BitStream *bitStream)
414 {
415 bitStream->Serialize(writeToBitstream, sourceClan);
416 bitStream->Serialize(writeToBitstream, dateSent);
417 bitStream->Serialize(writeToBitstream, joinRequestTarget);
418 }
Serialize(bool writeToBitstream,BitStream * bitStream)419 void BookmarkedUser::Serialize(bool writeToBitstream, BitStream *bitStream)
420 {
421 bitStream->Serialize(writeToBitstream, targetHandle);
422 bitStream->Serialize(writeToBitstream, type);
423 bitStream->Serialize(writeToBitstream, description);
424 bitStream->Serialize(writeToBitstream, dateWhenAdded);
425 }
Serialize(bool writeToBitstream,bool serializeOutput,BitStream * bitStream)426 void System_CreateTitle::Serialize( bool writeToBitstream, bool serializeOutput, BitStream *bitStream )
427 {
428 SerializeBase(writeToBitstream, serializeOutput, bitStream);
429 bitStream->Serialize(writeToBitstream, titleName);
430 bitStream->Serialize(writeToBitstream, titleSecretKey);
431 bitStream->Serialize(writeToBitstream, requiredAge);
432 binaryData->Serialize(writeToBitstream, bitStream);
433 }
PrevalidateInput(void)434 bool System_CreateTitle::PrevalidateInput(void)
435 {
436 //
437 if (!ValidateRequiredText(&titleName)) return false;
438 if (!ValidatePassword(&titleSecretKey)) return false;
439 if (!ValidateBinary(binaryData)) return false;
440 return true;
441 }
442
Serialize(bool writeToBitstream,bool serializeOutput,BitStream * bitStream)443 void System_DestroyTitle::Serialize( bool writeToBitstream, bool serializeOutput, BitStream *bitStream )
444 {
445 SerializeBase(writeToBitstream, serializeOutput, bitStream);
446 bitStream->Serialize(writeToBitstream, titleName);
447 }
448
Serialize(bool writeToBitstream,bool serializeOutput,BitStream * bitStream)449 void System_GetTitleRequiredAge::Serialize( bool writeToBitstream, bool serializeOutput, BitStream *bitStream )
450 {
451 SerializeBase(writeToBitstream, serializeOutput, bitStream);
452 bitStream->Serialize(writeToBitstream, titleName);
453 if (serializeOutput)
454 bitStream->Serialize(writeToBitstream, requiredAge);
455 }
456
Serialize(bool writeToBitstream,bool serializeOutput,BitStream * bitStream)457 void System_GetTitleBinaryData::Serialize( bool writeToBitstream, bool serializeOutput, BitStream *bitStream )
458 {
459 SerializeBase(writeToBitstream, serializeOutput, bitStream);
460 bitStream->Serialize(writeToBitstream, titleName);
461 if (serializeOutput)
462 binaryData->Serialize(writeToBitstream,bitStream);
463 }
464
Serialize(bool writeToBitstream,bool serializeOutput,BitStream * bitStream)465 void System_RegisterProfanity::Serialize( bool writeToBitstream, bool serializeOutput, BitStream *bitStream )
466 {
467 SerializeBase(writeToBitstream, serializeOutput, bitStream);
468 unsigned short listSize = (unsigned short) profanityWords.Size();
469 bitStream->SerializeCompressed(writeToBitstream, listSize);
470 for (unsigned int i=0; i < listSize; i++)
471 {
472 RakString obj;
473 if (writeToBitstream)
474 {
475 bitStream->Serialize(writeToBitstream, profanityWords[i]);
476 }
477 else
478 {
479 bitStream->Serialize(writeToBitstream, obj);
480 profanityWords.Insert(obj, __FILE__, __LINE__);
481 }
482 }
483 }
484
Serialize(bool writeToBitstream,bool serializeOutput,BitStream * bitStream)485 void System_BanUser::Serialize( bool writeToBitstream, bool serializeOutput, BitStream *bitStream )
486 {
487 SerializeBase(writeToBitstream, serializeOutput, bitStream);
488 bitStream->Serialize(writeToBitstream,banReason);
489 bitStream->Serialize(writeToBitstream,durationHours);
490 bitStream->Serialize(writeToBitstream,userName);
491 }
492
PrevalidateInput(void)493 bool System_BanUser::PrevalidateInput( void )
494 {
495 if (!ValidateHandle(&userName)) return false;
496 if (!ValidateRequiredText(&banReason)) return false;
497 if (durationHours<=0)
498 {
499 resultCode=L2RC_System_BanUser_INVALID_DURATION;
500 return false;
501 }
502 return true;
503 }
504
Serialize(bool writeToBitstream,bool serializeOutput,BitStream * bitStream)505 void System_UnbanUser::Serialize( bool writeToBitstream, bool serializeOutput, BitStream *bitStream )
506 {
507 SerializeBase(writeToBitstream, serializeOutput, bitStream);
508 bitStream->Serialize(writeToBitstream,reason);
509 bitStream->Serialize(writeToBitstream,userName);
510 }
511
PrevalidateInput(void)512 bool System_UnbanUser::PrevalidateInput( void )
513 {
514 if (!ValidateHandle(&userName)) return false;
515 if (!ValidateRequiredText(&reason)) return false;
516 return true;
517 }
518
Serialize(bool writeToBitstream,bool serializeOutput,BitStream * bitStream)519 void CDKey_Add::Serialize( bool writeToBitstream, bool serializeOutput, BitStream *bitStream )
520 {
521 SerializeBase(writeToBitstream, serializeOutput, bitStream);
522 bitStream->Serialize(writeToBitstream,titleName);
523 unsigned short listSize = (unsigned short) cdKeys.Size();
524 bitStream->SerializeCompressed(writeToBitstream, listSize);
525 for (unsigned int i=0; i < listSize; i++)
526 {
527 RakString obj;
528 if (writeToBitstream)
529 {
530 bitStream->Serialize(writeToBitstream, cdKeys[i]);
531 }
532 else
533 {
534 bitStream->Serialize(writeToBitstream, obj);
535 cdKeys.Insert(obj, __FILE__, __LINE__);
536 }
537 }
538 }
539
PrevalidateInput(void)540 bool CDKey_Add::PrevalidateInput( void )
541 {
542 for (unsigned int i=0; i < cdKeys.Size(); i++)
543 if (!ValidateRequiredText(&cdKeys[i])) return false;
544 if (!ValidateRequiredText(&titleName)) return false;
545 return true;
546 }
547
Serialize(bool writeToBitstream,bool serializeOutput,BitStream * bitStream)548 void CDKey_GetStatus::Serialize( bool writeToBitstream, bool serializeOutput, BitStream *bitStream )
549 {
550 SerializeBase(writeToBitstream, serializeOutput, bitStream);
551 bitStream->Serialize(writeToBitstream,cdKey);
552 bitStream->Serialize(writeToBitstream,titleName);
553 if (serializeOutput)
554 {
555 bitStream->Serialize(writeToBitstream,usable);
556 bitStream->Serialize(writeToBitstream,usedBy);
557 bitStream->Serialize(writeToBitstream,activationDate);
558 }
559 }
560
PrevalidateInput(void)561 bool CDKey_GetStatus::PrevalidateInput( void )
562 {
563 if (!ValidateRequiredText(&cdKey)) return false;
564 if (!ValidateRequiredText(&titleName)) return false;
565 return true;
566 }
567
Serialize(bool writeToBitstream,bool serializeOutput,BitStream * bitStream)568 void CDKey_Use::Serialize( bool writeToBitstream, bool serializeOutput, BitStream *bitStream )
569 {
570 SerializeBase(writeToBitstream, serializeOutput, bitStream);
571 bitStream->Serialize(writeToBitstream,cdKey);
572 bitStream->Serialize(writeToBitstream,titleName);
573 bitStream->Serialize(writeToBitstream,userName);
574 }
575
PrevalidateInput(void)576 bool CDKey_Use::PrevalidateInput( void )
577 {
578 if (!ValidateHandle(&userName)) return false;
579 if (!ValidateRequiredText(&cdKey)) return false;
580 if (!ValidateRequiredText(&titleName)) return false;
581 return true;
582 }
583
Serialize(bool writeToBitstream,bool serializeOutput,BitStream * bitStream)584 void CDKey_FlagStolen::Serialize( bool writeToBitstream, bool serializeOutput, BitStream *bitStream )
585 {
586 SerializeBase(writeToBitstream, serializeOutput, bitStream);
587 bitStream->Serialize(writeToBitstream,cdKey);
588 bitStream->Serialize(writeToBitstream,titleName);
589 bitStream->Serialize(writeToBitstream,userUsingThisKey);
590 bitStream->Serialize(writeToBitstream,wasStolen);
591 }
592
PrevalidateInput(void)593 bool CDKey_FlagStolen::PrevalidateInput( void )
594 {
595 //
596 if (!ValidateRequiredText(&cdKey)) return false;
597 if (!ValidateRequiredText(&titleName)) return false;
598 return true;
599 }
600
Serialize(bool writeToBitstream,bool serializeOutput,BitStream * bitStream)601 void Client_Login::Serialize( bool writeToBitstream, bool serializeOutput, BitStream *bitStream )
602 {
603 SerializeBase(writeToBitstream, serializeOutput, bitStream);
604 bitStream->Serialize(writeToBitstream,userPassword);
605 bitStream->Serialize(writeToBitstream,allowMultipleLogins);
606 bitStream->Serialize(writeToBitstream,titleName);
607 bitStream->Serialize(writeToBitstream,titleSecretKey);
608 bitStream->Serialize(writeToBitstream,userName);
609
610 if (serializeOutput)
611 {
612 bitStream->Serialize(writeToBitstream,bannedReason);
613 bitStream->Serialize(writeToBitstream,whenBanned);
614 bitStream->Serialize(writeToBitstream,bannedExpiration);
615 }
616 }
617
PrevalidateInput(void)618 bool Client_Login::PrevalidateInput( void )
619 {
620 if (!ValidateHandle(&userName)) return false;
621 if (!ValidateHandle(&titleName)) return false;
622 if (!ValidateRequiredText(&userPassword)) return false;
623 if (!ValidateRequiredText(&titleSecretKey)) return false;
624 return true;
625 }
Serialize(bool writeToBitstream,bool serializeOutput,BitStream * bitStream)626 void Client_RegisterAccount::Serialize( bool writeToBitstream, bool serializeOutput, BitStream *bitStream )
627 {
628 SerializeBase(writeToBitstream, serializeOutput, bitStream);
629 createAccountParameters.Serialize(writeToBitstream, bitStream);
630 bitStream->Serialize(writeToBitstream,cdKey);
631 bitStream->Serialize(writeToBitstream,titleName);
632 bitStream->Serialize(writeToBitstream,userName);
633 }
634
PrevalidateInput(void)635 bool Client_RegisterAccount::PrevalidateInput( void )
636 {
637 if (!ValidateHandle(&userName)) return false;
638 // If either first name or last name is set, then both must be set correctly.
639 if (createAccountParameters.firstName.IsEmpty()==false ||
640 createAccountParameters.lastName.IsEmpty()==false)
641 {
642 if (!ValidateHandle(&createAccountParameters.firstName)) return false;
643 if (!ValidateHandle(&createAccountParameters.lastName)) return false;
644 }
645 if (!ValidatePassword(&createAccountParameters.password)) return false;
646 // Don't require password recovery
647 // if (!ValidateRequiredText(&createAccountParameters.passwordRecoveryQuestion)) return false;
648 // if (!ValidateRequiredText(&createAccountParameters.passwordRecoveryAnswer)) return false;
649 if (createAccountParameters.emailAddress.IsEmpty()==false &&
650 !ValidateEmailAddress(&createAccountParameters.emailAddress)) return false;
651 return true;
652 }
653
Serialize(bool writeToBitstream,bool serializeOutput,BitStream * bitStream)654 void System_SetEmailAddressValidated::Serialize( bool writeToBitstream, bool serializeOutput, BitStream *bitStream )
655 {
656 SerializeBase(writeToBitstream, serializeOutput, bitStream);
657 bitStream->Serialize(writeToBitstream,validated);
658 bitStream->Serialize(writeToBitstream,userName);
659 }
PrevalidateInput(void)660 bool System_SetEmailAddressValidated::PrevalidateInput( void )
661 {
662 if (!ValidateHandle(&userName)) return false;
663 return true;
664 }
Serialize(bool writeToBitstream,bool serializeOutput,RakNet::BitStream * bitStream)665 void Client_ValidateHandle::Serialize( bool writeToBitstream, bool serializeOutput, RakNet::BitStream *bitStream )
666 {
667 SerializeBase(writeToBitstream, serializeOutput, bitStream);
668 bitStream->Serialize(writeToBitstream,userName);
669 }
PrevalidateInput(void)670 bool Client_ValidateHandle::PrevalidateInput(void)
671 {
672 if (!ValidateHandle(&userName)) return false;
673 return true;
674 }
675
Serialize(bool writeToBitstream,bool serializeOutput,BitStream * bitStream)676 void System_DeleteAccount::Serialize( bool writeToBitstream, bool serializeOutput, BitStream *bitStream )
677 {
678 SerializeBase(writeToBitstream, serializeOutput, bitStream);
679 bitStream->Serialize(writeToBitstream,password);
680 bitStream->Serialize(writeToBitstream,userName);
681 }
682
PrevalidateInput(void)683 bool System_DeleteAccount::PrevalidateInput( void )
684 {
685 if (!ValidateHandle(&userName)) return false;
686 if (!ValidatePassword(&password)) return false;
687 return true;
688 }
PrevalidateInput(void)689 bool System_PruneAccounts::PrevalidateInput(void)
690 {
691 if (deleteAccountsNotLoggedInDays==0) return false;
692 return true;
693 }
Serialize(bool writeToBitstream,bool serializeOutput,BitStream * bitStream)694 void System_PruneAccounts::Serialize( bool writeToBitstream, bool serializeOutput, BitStream *bitStream )
695 {
696 SerializeBase(writeToBitstream, serializeOutput, bitStream);
697 bitStream->Serialize(writeToBitstream,deleteAccountsNotLoggedInDays);
698 }
PrevalidateInput(void)699 bool Client_GetEmailAddress::PrevalidateInput(void)
700 {
701 if (!ValidateHandle(&userName)) return false;
702 return true;
703 }
Serialize(bool writeToBitstream,bool serializeOutput,BitStream * bitStream)704 void Client_GetEmailAddress::Serialize( bool writeToBitstream, bool serializeOutput, BitStream *bitStream )
705 {
706 SerializeBase(writeToBitstream, serializeOutput, bitStream);
707 bitStream->Serialize(writeToBitstream,userName);
708 if (serializeOutput)
709 {
710 bitStream->Serialize(writeToBitstream,emailAddress);
711 bitStream->Serialize(writeToBitstream,emailAddressValidated);
712 }
713 }
PrevalidateInput(void)714 bool Client_GetPasswordRecoveryQuestionByHandle::PrevalidateInput(void)
715 {
716 if (!ValidateHandle(&userName)) return false;
717 return true;
718 }
Serialize(bool writeToBitstream,bool serializeOutput,BitStream * bitStream)719 void Client_GetPasswordRecoveryQuestionByHandle::Serialize( bool writeToBitstream, bool serializeOutput, BitStream *bitStream )
720 {
721 SerializeBase(writeToBitstream, serializeOutput, bitStream);
722 bitStream->Serialize(writeToBitstream,userName);
723 if (serializeOutput)
724 {
725 bitStream->Serialize(writeToBitstream,passwordRecoveryQuestion);
726 }
727 }
PrevalidateInput(void)728 bool Client_GetPasswordByPasswordRecoveryAnswer::PrevalidateInput(void)
729 {
730 if (!ValidateHandle(&userName)) return false;
731 if (!ValidateRequiredText( &passwordRecoveryAnswer )) return false;
732 return true;
733 }
Serialize(bool writeToBitstream,bool serializeOutput,BitStream * bitStream)734 void Client_GetPasswordByPasswordRecoveryAnswer::Serialize( bool writeToBitstream, bool serializeOutput, BitStream *bitStream )
735 {
736 SerializeBase(writeToBitstream, serializeOutput, bitStream);
737 bitStream->Serialize(writeToBitstream,userName);
738 bitStream->Serialize(writeToBitstream,passwordRecoveryAnswer);
739 if (serializeOutput)
740 {
741 bitStream->Serialize(writeToBitstream,password);
742 }
743 }
744
Serialize(bool writeToBitstream,bool serializeOutput,BitStream * bitStream)745 void Client_ChangeHandle::Serialize( bool writeToBitstream, bool serializeOutput, BitStream *bitStream )
746 {
747 SerializeBase(writeToBitstream, serializeOutput, bitStream);
748 bitStream->Serialize(writeToBitstream,userName);
749 bitStream->Serialize(writeToBitstream,newHandle);
750 }
PrevalidateInput(void)751 bool Client_ChangeHandle::PrevalidateInput(void)
752 {
753 if (!ValidateHandle(&userName)) return false;
754 if (!ValidateHandle(&newHandle)) return false;
755 if (userName==newHandle)
756 {
757 resultCode=L2RC_Client_ChangeHandle_HANDLE_NOT_CHANGED;
758 return false;
759 }
760 return true;
761 }
Serialize(bool writeToBitstream,bool serializeOutput,BitStream * bitStream)762 void Client_UpdateAccount::Serialize( bool writeToBitstream, bool serializeOutput, BitStream *bitStream )
763 {
764 SerializeBase(writeToBitstream, serializeOutput, bitStream);
765 createAccountParameters.Serialize(writeToBitstream, bitStream);
766 }
767
PrevalidateInput(void)768 bool Client_UpdateAccount::PrevalidateInput( void )
769 {
770 if (!ValidateHandle(&createAccountParameters.firstName)) return false;
771 if (!ValidateHandle(&createAccountParameters.lastName)) return false;
772 if (!ValidatePassword(&createAccountParameters.password)) return false;
773 if (!ValidateRequiredText(&createAccountParameters.passwordRecoveryQuestion)) return false;
774 if (!ValidateRequiredText(&createAccountParameters.passwordRecoveryAnswer)) return false;
775 return true;
776 }
777
Serialize(bool writeToBitstream,bool serializeOutput,BitStream * bitStream)778 void Client_GetAccountDetails::Serialize( bool writeToBitstream, bool serializeOutput, BitStream *bitStream )
779 {
780 SerializeBase(writeToBitstream, serializeOutput, bitStream);
781 if (serializeOutput)
782 {
783 createAccountParameters.Serialize(writeToBitstream, bitStream);
784 }
785 }
786
Serialize(bool writeToBitstream,bool serializeOutput,BitStream * bitStream)787 void Client_StartIgnore::Serialize( bool writeToBitstream, bool serializeOutput, BitStream *bitStream )
788 {
789 SerializeBase(writeToBitstream, serializeOutput, bitStream);
790 bitStream->Serialize(writeToBitstream,targetHandle);
791 }
792
PrevalidateInput(void)793 bool Client_StartIgnore::PrevalidateInput( void )
794 {
795 if (!ValidateHandle(&targetHandle)) return false;
796 return true;
797 }
798
Serialize(bool writeToBitstream,bool serializeOutput,BitStream * bitStream)799 void Client_StopIgnore::Serialize( bool writeToBitstream, bool serializeOutput, BitStream *bitStream )
800 {
801 SerializeBase(writeToBitstream, serializeOutput, bitStream);
802 bitStream->Serialize(writeToBitstream,targetHandle);
803 }
804
PrevalidateInput(void)805 bool Client_StopIgnore::PrevalidateInput( void )
806 {
807 if (!ValidateHandle(&targetHandle)) return false;
808 return true;
809 }
810
Serialize(bool writeToBitstream,bool serializeOutput,BitStream * bitStream)811 void Client_GetIgnoreList::Serialize( bool writeToBitstream, bool serializeOutput, BitStream *bitStream )
812 {
813 SerializeBase(writeToBitstream, serializeOutput, bitStream);
814 if (serializeOutput)
815 {
816 unsigned short listSize = (unsigned short) ignoredHandles.Size();
817 bitStream->SerializeCompressed(writeToBitstream, listSize);
818 for (unsigned int i=0; i < listSize; i++)
819 {
820 RakString obj;
821 if (writeToBitstream)
822 {
823 bitStream->Serialize(writeToBitstream, ignoredHandles[i]);
824 }
825 else
826 {
827 bitStream->Serialize(writeToBitstream, obj);
828 ignoredHandles.Insert(obj, __FILE__, __LINE__);
829 }
830 }
831 }
832 }
PrevalidateInput(void)833 bool Client_PerTitleIntegerStorage::PrevalidateInput(void)
834 {
835 if (!ValidateRequiredText(&titleName)) return false;
836 return true;
837 }
Serialize(bool writeToBitstream,bool serializeOutput,BitStream * bitStream)838 void Client_PerTitleIntegerStorage::Serialize( bool writeToBitstream, bool serializeOutput, BitStream *bitStream )
839 {
840 SerializeBase(writeToBitstream, serializeOutput, bitStream);
841 bitStream->Serialize(writeToBitstream,titleName);
842 bitStream->Serialize(writeToBitstream,slotIndex);
843 unsigned char c;
844 c = (unsigned char)addConditionForOperation;
845 bitStream->Serialize(writeToBitstream,c);
846 addConditionForOperation = (PTIS_Condition) c;
847 c = (unsigned char)operationToPerform;
848 bitStream->Serialize(writeToBitstream,c);
849 operationToPerform = (PTIS_Operation) c;
850 bitStream->Serialize(writeToBitstream,conditionValue);
851 if (operationToPerform!=PTISO_DELETE)
852 {
853 if (operationToPerform==PTISO_ADD || operationToPerform==PTISO_WRITE)
854 bitStream->Serialize(writeToBitstream,inputValue);
855 if (serializeOutput)
856 {
857 if (operationToPerform==PTISO_WRITE)
858 outputValue=inputValue;
859 else if (operationToPerform==PTISO_READ ||
860 operationToPerform==PTISO_ADD)
861 bitStream->Serialize(writeToBitstream,outputValue);
862 }
863 }
864 }
PrevalidateInput(void)865 bool Client_PerTitleBinaryStorage::PrevalidateInput(void)
866 {
867 if (!ValidateRequiredText(&titleName)) return false;
868 if (!ValidateBinary(binaryData)) return false;
869 return true;
870 }
Serialize(bool writeToBitstream,bool serializeOutput,BitStream * bitStream)871 void Client_PerTitleBinaryStorage::Serialize( bool writeToBitstream, bool serializeOutput, BitStream *bitStream )
872 {
873 SerializeBase(writeToBitstream, serializeOutput, bitStream);
874 bitStream->Serialize(writeToBitstream,titleName);
875 bitStream->Serialize(writeToBitstream,slotIndex);
876 if (operationToPerform!=PTISO_DELETE)
877 binaryData->Serialize(writeToBitstream, bitStream);
878 }
Serialize(bool writeToBitstream,bool serializeOutput,BitStream * bitStream)879 void Client_SetPresence::Serialize( bool writeToBitstream, bool serializeOutput, BitStream *bitStream )
880 {
881 SerializeBase(writeToBitstream, serializeOutput, bitStream);
882 presence.Serialize(bitStream,writeToBitstream);
883 }
884 // bool Client_SetPresence::ServerPreDBMemoryImpl( Lobby2Server *server, RakString userHandle )
885 // {
886 // // This has to go in Lobby2Message_PGSQL.h because the server and client both share this file, and the client doesn't know about the server
887 // server->SetPresence( presence, systemAddress );
888 // return true;
889 // }
Serialize(bool writeToBitstream,bool serializeOutput,BitStream * bitStream)890 void Client_GetPresence::Serialize( bool writeToBitstream, bool serializeOutput, BitStream *bitStream )
891 {
892 SerializeBase(writeToBitstream, serializeOutput, bitStream);
893 bitStream->Serialize(writeToBitstream,userHandle);
894 if (serializeOutput)
895 {
896 presence.Serialize(bitStream,writeToBitstream);
897 }
898 }
899 // bool Client_GetPresence::ServerPreDBMemoryImpl( Lobby2Server *server, RakString userHandle )
900 // {
901 // // This has to go in Lobby2Message_PGSQL.h because the server and client both share this file, and the client doesn't know about the server
902 // server->GetPresence( presence, userHandle );
903 // return true;
904 // }
Serialize(bool writeToBitstream,bool serializeOutput,BitStream * bitStream)905 void Friends_SendInvite::Serialize( bool writeToBitstream, bool serializeOutput, BitStream *bitStream )
906 {
907 SerializeBase(writeToBitstream, serializeOutput, bitStream);
908 bitStream->Serialize(writeToBitstream,targetHandle);
909 bitStream->Serialize(writeToBitstream,subject);
910 bitStream->Serialize(writeToBitstream,body);
911 bitStream->Serialize(writeToBitstream,emailStatus);
912 binaryData->Serialize(writeToBitstream, bitStream);
913 }
914
PrevalidateInput(void)915 bool Friends_SendInvite::PrevalidateInput( void )
916 {
917 if (!ValidateHandle(&targetHandle)) return false;
918 // if (!ValidateRequiredText(&subject) && !ValidateRequiredText(&body)) return false;
919 if (!ValidateBinary(binaryData)) return false;
920 return true;
921 }
922
Serialize(bool writeToBitstream,bool serializeOutput,BitStream * bitStream)923 void Friends_AcceptInvite::Serialize( bool writeToBitstream, bool serializeOutput, BitStream *bitStream )
924 {
925 SerializeBase(writeToBitstream, serializeOutput, bitStream);
926 bitStream->Serialize(writeToBitstream,targetHandle);
927 bitStream->Serialize(writeToBitstream,subject);
928 bitStream->Serialize(writeToBitstream,body);
929 bitStream->Serialize(writeToBitstream,emailStatus);
930 binaryData->Serialize(writeToBitstream, bitStream);
931 if (serializeOutput)
932 presence.Serialize(bitStream,writeToBitstream);
933 }
934
PrevalidateInput(void)935 bool Friends_AcceptInvite::PrevalidateInput( void )
936 {
937 if (!ValidateHandle(&targetHandle)) return false;
938 // if (!ValidateRequiredText(&subject) && !ValidateRequiredText(&body)) return false;
939 if (!ValidateBinary(binaryData)) return false;
940 return true;
941 }
942
Serialize(bool writeToBitstream,bool serializeOutput,BitStream * bitStream)943 void Friends_RejectInvite::Serialize( bool writeToBitstream, bool serializeOutput, BitStream *bitStream )
944 {
945 SerializeBase(writeToBitstream, serializeOutput, bitStream);
946 bitStream->Serialize(writeToBitstream,targetHandle);
947 bitStream->Serialize(writeToBitstream,subject);
948 bitStream->Serialize(writeToBitstream,body);
949 bitStream->Serialize(writeToBitstream,emailStatus);
950 binaryData->Serialize(writeToBitstream, bitStream);
951 }
952
PrevalidateInput(void)953 bool Friends_RejectInvite::PrevalidateInput( void )
954 {
955 if (!ValidateHandle(&targetHandle)) return false;
956 // if (!ValidateRequiredText(&subject) && !ValidateRequiredText(&body)) return false;
957 if (!ValidateBinary(binaryData)) return false;
958 return true;
959 }
960
Serialize(bool writeToBitstream,bool serializeOutput,BitStream * bitStream)961 void Friends_GetInvites::Serialize( bool writeToBitstream, bool serializeOutput, BitStream *bitStream )
962 {
963 SerializeBase(writeToBitstream, serializeOutput, bitStream);
964 if (serializeOutput)
965 {
966 unsigned short listSize = (unsigned short) invitesSent.Size();
967 bitStream->SerializeCompressed(writeToBitstream, listSize);
968 for (unsigned int i=0; i < listSize; i++)
969 {
970 FriendInfo obj;
971 if (writeToBitstream)
972 {
973 invitesSent[i].Serialize(writeToBitstream, bitStream);
974 }
975 else
976 {
977 obj.Serialize(writeToBitstream, bitStream);
978 invitesSent.Insert(obj, __FILE__, __LINE__);
979 }
980 }
981 listSize = (unsigned short) invitesReceived.Size();
982 bitStream->SerializeCompressed(writeToBitstream, listSize);
983 for (unsigned int i=0; i < listSize; i++)
984 {
985 FriendInfo obj;
986 if (writeToBitstream)
987 {
988 invitesReceived[i].Serialize(writeToBitstream, bitStream);
989 }
990 else
991 {
992 obj.Serialize(writeToBitstream, bitStream);
993 invitesReceived.Insert(obj, __FILE__, __LINE__);
994 }
995 }
996 }
997 }
998
Serialize(bool writeToBitstream,bool serializeOutput,BitStream * bitStream)999 void Friends_GetFriends::Serialize( bool writeToBitstream, bool serializeOutput, BitStream *bitStream )
1000 {
1001 SerializeBase(writeToBitstream, serializeOutput, bitStream);
1002 if (serializeOutput)
1003 {
1004 unsigned short listSize = (unsigned short) myFriends.Size();
1005 bitStream->SerializeCompressed(writeToBitstream, listSize);
1006 for (unsigned int i=0; i < listSize; i++)
1007 {
1008 FriendInfo obj;
1009 if (writeToBitstream)
1010 {
1011 myFriends[i].Serialize(writeToBitstream, bitStream);
1012 }
1013 else
1014 {
1015 obj.Serialize(writeToBitstream, bitStream);
1016 myFriends.Insert(obj, __FILE__, __LINE__);
1017 }
1018 }
1019 }
1020 }
1021
Serialize(bool writeToBitstream,bool serializeOutput,BitStream * bitStream)1022 void Friends_Remove::Serialize( bool writeToBitstream, bool serializeOutput, BitStream *bitStream )
1023 {
1024 SerializeBase(writeToBitstream, serializeOutput, bitStream);
1025 bitStream->Serialize(writeToBitstream,targetHandle);
1026 bitStream->Serialize(writeToBitstream,subject);
1027 bitStream->Serialize(writeToBitstream,body);
1028 bitStream->Serialize(writeToBitstream,emailStatus);
1029 binaryData->Serialize(writeToBitstream, bitStream);
1030 }
1031
PrevalidateInput(void)1032 bool Friends_Remove::PrevalidateInput( void )
1033 {
1034 if (!ValidateHandle(&targetHandle)) return false;
1035 // if (!ValidateRequiredText(&subject) && !ValidateRequiredText(&body)) return false;
1036 if (!ValidateBinary(binaryData)) return false;
1037 return true;
1038 }
1039
Serialize(bool writeToBitstream,bool serializeOutput,BitStream * bitStream)1040 void BookmarkedUsers_Add::Serialize( bool writeToBitstream, bool serializeOutput, BitStream *bitStream )
1041 {
1042 SerializeBase(writeToBitstream, serializeOutput, bitStream);
1043 bitStream->Serialize(writeToBitstream,targetHandle);
1044 bitStream->Serialize(writeToBitstream,type);
1045 bitStream->Serialize(writeToBitstream,description);
1046 }
1047
PrevalidateInput(void)1048 bool BookmarkedUsers_Add::PrevalidateInput( void )
1049 {
1050 if (!ValidateHandle(&targetHandle)) return false;
1051 return true;
1052 }
Serialize(bool writeToBitstream,bool serializeOutput,BitStream * bitStream)1053 void BookmarkedUsers_Remove::Serialize( bool writeToBitstream, bool serializeOutput, BitStream *bitStream )
1054 {
1055 SerializeBase(writeToBitstream, serializeOutput, bitStream);
1056 bitStream->Serialize(writeToBitstream,targetHandle);
1057 bitStream->Serialize(writeToBitstream,type);
1058 }
1059
PrevalidateInput(void)1060 bool BookmarkedUsers_Remove::PrevalidateInput( void )
1061 {
1062 if (!ValidateHandle(&targetHandle)) return false;
1063 return true;
1064 }
Serialize(bool writeToBitstream,bool serializeOutput,BitStream * bitStream)1065 void BookmarkedUsers_Get::Serialize( bool writeToBitstream, bool serializeOutput, BitStream *bitStream )
1066 {
1067 SerializeBase(writeToBitstream, serializeOutput, bitStream);
1068 if (serializeOutput)
1069 {
1070 unsigned short listSize = (unsigned short) bookmarkedUsers.Size();
1071 bitStream->SerializeCompressed(writeToBitstream, listSize);
1072 for (unsigned int i=0; i < listSize; i++)
1073 {
1074 BookmarkedUser obj;
1075 if (writeToBitstream)
1076 {
1077 bookmarkedUsers[i].Serialize(writeToBitstream, bitStream);
1078 }
1079 else
1080 {
1081 obj.Serialize(writeToBitstream, bitStream);
1082 bookmarkedUsers.Insert(obj, __FILE__, __LINE__);
1083 }
1084 }
1085 }
1086 }
1087
Serialize(bool writeToBitstream,bool serializeOutput,BitStream * bitStream)1088 void Emails_Send::Serialize( bool writeToBitstream, bool serializeOutput, BitStream *bitStream )
1089 {
1090 SerializeBase(writeToBitstream, serializeOutput, bitStream);
1091 bitStream->Serialize(writeToBitstream,subject);
1092 bitStream->Serialize(writeToBitstream,body);
1093 bitStream->Serialize(writeToBitstream,status);
1094 binaryData->Serialize(writeToBitstream, bitStream);
1095 unsigned short listSize = (unsigned short) recipients.Size();
1096 bitStream->SerializeCompressed(writeToBitstream, listSize);
1097 for (unsigned int i=0; i < listSize; i++)
1098 {
1099 RakString obj;
1100 if (writeToBitstream)
1101 {
1102 bitStream->Serialize(writeToBitstream, recipients[i]);
1103 }
1104 else
1105 {
1106 bitStream->Serialize(writeToBitstream, obj);
1107 recipients.Insert(obj, __FILE__, __LINE__);
1108 }
1109 }
1110 }
1111
PrevalidateInput(void)1112 bool Emails_Send::PrevalidateInput( void )
1113 {
1114 for (unsigned int i=0; i < recipients.Size(); i++)
1115 if (!ValidateHandle(&recipients[i])) return false;
1116 if (!ValidateRequiredText(&subject) && !ValidateRequiredText(&body)) return false;
1117 if (!ValidateBinary(binaryData)) return false;
1118 if (recipients.Size()==0)
1119 {
1120 resultCode=L2RC_Emails_Send_NO_RECIPIENTS;
1121 return false;
1122 }
1123 return true;
1124 }
1125
Serialize(bool writeToBitstream,bool serializeOutput,BitStream * bitStream)1126 void Emails_Get::Serialize( bool writeToBitstream, bool serializeOutput, BitStream *bitStream )
1127 {
1128 SerializeBase(writeToBitstream, serializeOutput, bitStream);
1129
1130 unsigned short listSize;
1131
1132 bitStream->Serialize(writeToBitstream,unreadEmailsOnly);
1133 bitStream->Serialize(writeToBitstream,emailIdsOnly);
1134
1135 listSize = (unsigned short) emailsToRetrieve.Size();
1136 bitStream->SerializeCompressed(writeToBitstream, listSize);
1137 for (unsigned int i=0; i < listSize; i++)
1138 {
1139 unsigned int id;
1140 if (writeToBitstream)
1141 {
1142 bitStream->Write(emailsToRetrieve[i]);
1143 }
1144 else
1145 {
1146 bitStream->Read(id);
1147 emailsToRetrieve.Push(id,__FILE__, __LINE__);
1148 }
1149 }
1150
1151 if (serializeOutput)
1152 {
1153 listSize = (unsigned short) emailResults.Size();
1154 bitStream->SerializeCompressed(writeToBitstream, listSize);
1155 for (unsigned int i=0; i < listSize; i++)
1156 {
1157 EmailResult obj;
1158 if (writeToBitstream)
1159 {
1160 emailResults[i].Serialize( writeToBitstream, bitStream );
1161 }
1162 else
1163 {
1164 obj.Serialize( writeToBitstream, bitStream );
1165 emailResults.Insert(obj, __FILE__, __LINE__);
1166 }
1167 }
1168 }
1169 }
1170
Serialize(bool writeToBitstream,bool serializeOutput,BitStream * bitStream)1171 void Emails_Delete::Serialize( bool writeToBitstream, bool serializeOutput, BitStream *bitStream )
1172 {
1173 SerializeBase(writeToBitstream, serializeOutput, bitStream);
1174 bitStream->Serialize(writeToBitstream,emailId);
1175 }
1176
Serialize(bool writeToBitstream,bool serializeOutput,BitStream * bitStream)1177 void Emails_SetStatus::Serialize( bool writeToBitstream, bool serializeOutput, BitStream *bitStream )
1178 {
1179 SerializeBase(writeToBitstream, serializeOutput, bitStream);
1180 bitStream->Serialize(writeToBitstream,emailId);
1181 bitStream->Serialize(writeToBitstream,updateStatusFlag);
1182 bitStream->Serialize(writeToBitstream,updateMarkedRead);
1183 bitStream->Serialize(writeToBitstream,newStatusFlag);
1184 bitStream->Serialize(writeToBitstream,isNowMarkedRead);
1185 }
PrevalidateInput(void)1186 bool Emails_SetStatus::PrevalidateInput(void)
1187 {
1188 if (updateStatusFlag==false && updateMarkedRead==false)
1189 {
1190 resultCode=L2RC_Emails_SetStatus_NOTHING_TO_DO;
1191 return false;
1192 }
1193 return true;
1194 }
Serialize(bool writeToBitstream,bool serializeOutput,BitStream * bitStream)1195 void Ranking_SubmitMatch::Serialize( bool writeToBitstream, bool serializeOutput, BitStream *bitStream )
1196 {
1197 SerializeBase(writeToBitstream, serializeOutput, bitStream);
1198 bitStream->Serialize(writeToBitstream,titleName);
1199 bitStream->Serialize(writeToBitstream,gameType);
1200 submittedMatch.Serialize(writeToBitstream, bitStream);
1201 }
1202
PrevalidateInput(void)1203 bool Ranking_SubmitMatch::PrevalidateInput( void )
1204 {
1205 if (!ValidateRequiredText(&titleName)) return false;
1206 if (!ValidateRequiredText(&gameType)) return false;
1207 if (!ValidateBinary(submittedMatch.binaryData)) return false;
1208 if (submittedMatch.matchParticipants.Size()==0)
1209 {
1210 resultCode=L2RC_Ranking_SubmitMatch_NO_PARTICIPANTS;
1211 return false;
1212 }
1213 for (unsigned int i=0; i < submittedMatch.matchParticipants.Size(); i++)
1214 if (!ValidateHandle(&submittedMatch.matchParticipants[i].handle)) return false;
1215 return true;
1216 }
1217
Serialize(bool writeToBitstream,bool serializeOutput,BitStream * bitStream)1218 void Ranking_GetMatches::Serialize( bool writeToBitstream, bool serializeOutput, BitStream *bitStream )
1219 {
1220 SerializeBase(writeToBitstream, serializeOutput, bitStream);
1221 bitStream->Serialize(writeToBitstream,titleName);
1222 bitStream->Serialize(writeToBitstream,gameType);
1223 if (serializeOutput)
1224 {
1225 unsigned short listSize = (unsigned short) submittedMatches.Size();
1226 bitStream->SerializeCompressed(writeToBitstream, listSize);
1227 for (unsigned int i=0; i < listSize; i++)
1228 {
1229 SubmittedMatch obj;
1230 if (writeToBitstream)
1231 {
1232 bitStream->Serialize(writeToBitstream, submittedMatches[i]);
1233 }
1234 else
1235 {
1236 bitStream->Serialize(writeToBitstream, obj);
1237 submittedMatches.Insert(obj, __FILE__, __LINE__);
1238 }
1239 }
1240 }
1241 }
1242
PrevalidateInput(void)1243 bool Ranking_GetMatches::PrevalidateInput( void )
1244 {
1245 if (!ValidateRequiredText(&titleName)) return false;
1246 if (!ValidateRequiredText(&gameType)) return false;
1247 return true;
1248 }
1249
Serialize(bool writeToBitstream,bool serializeOutput,BitStream * bitStream)1250 void Ranking_GetMatchBinaryData::Serialize( bool writeToBitstream, bool serializeOutput, BitStream *bitStream )
1251 {
1252 SerializeBase(writeToBitstream, serializeOutput, bitStream);
1253 bitStream->Serialize(writeToBitstream,matchID);
1254 if (serializeOutput)
1255 {
1256 binaryData->Serialize(writeToBitstream,bitStream);
1257 }
1258 }
1259
Serialize(bool writeToBitstream,bool serializeOutput,BitStream * bitStream)1260 void Ranking_GetTotalScore::Serialize( bool writeToBitstream, bool serializeOutput, BitStream *bitStream )
1261 {
1262 SerializeBase(writeToBitstream, serializeOutput, bitStream);
1263 bitStream->Serialize(writeToBitstream,titleName);
1264 bitStream->Serialize(writeToBitstream,gameType);
1265 bitStream->Serialize(writeToBitstream,targetHandle);
1266 if (serializeOutput)
1267 {
1268 bitStream->Serialize(writeToBitstream,scoreSum);
1269 bitStream->Serialize(writeToBitstream,numScoresSubmitted);
1270 }
1271 }
1272
PrevalidateInput(void)1273 bool Ranking_GetTotalScore::PrevalidateInput( void )
1274 {
1275 if (!ValidateHandle(&targetHandle)) return false;
1276 if (!ValidateRequiredText(&titleName)) return false;
1277 if (!ValidateRequiredText(&gameType)) return false;
1278 return true;
1279 }
1280
Serialize(bool writeToBitstream,bool serializeOutput,BitStream * bitStream)1281 void Ranking_WipeScoresForPlayer::Serialize( bool writeToBitstream, bool serializeOutput, BitStream *bitStream )
1282 {
1283 SerializeBase(writeToBitstream, serializeOutput, bitStream);
1284 bitStream->Serialize(writeToBitstream,titleName);
1285 bitStream->Serialize(writeToBitstream,gameType);
1286 bitStream->Serialize(writeToBitstream,targetHandle);
1287 }
1288
PrevalidateInput(void)1289 bool Ranking_WipeScoresForPlayer::PrevalidateInput( void )
1290 {
1291 if (!ValidateHandle(&targetHandle)) return false;
1292 if (!ValidateRequiredText(&titleName)) return false;
1293 if (!ValidateRequiredText(&gameType)) return false;
1294 return true;
1295 }
1296
Serialize(bool writeToBitstream,bool serializeOutput,BitStream * bitStream)1297 void Ranking_WipeMatches::Serialize( bool writeToBitstream, bool serializeOutput, BitStream *bitStream )
1298 {
1299 SerializeBase(writeToBitstream, serializeOutput, bitStream);
1300 bitStream->Serialize(writeToBitstream,titleName);
1301 bitStream->Serialize(writeToBitstream,gameType);
1302 }
1303
PrevalidateInput(void)1304 bool Ranking_WipeMatches::PrevalidateInput( void )
1305 {
1306 if (!ValidateRequiredText(&titleName)) return false;
1307 if (!ValidateRequiredText(&gameType)) return false;
1308 return true;
1309 }
1310
Serialize(bool writeToBitstream,bool serializeOutput,BitStream * bitStream)1311 void Ranking_PruneMatches::Serialize( bool writeToBitstream, bool serializeOutput, BitStream *bitStream )
1312 {
1313 SerializeBase(writeToBitstream, serializeOutput, bitStream);
1314 bitStream->Serialize(writeToBitstream,pruneTimeDays);
1315 }
1316
Serialize(bool writeToBitstream,bool serializeOutput,BitStream * bitStream)1317 void Ranking_UpdateRating::Serialize( bool writeToBitstream, bool serializeOutput, BitStream *bitStream )
1318 {
1319 SerializeBase(writeToBitstream, serializeOutput, bitStream);
1320 bitStream->Serialize(writeToBitstream,titleName);
1321 bitStream->Serialize(writeToBitstream,gameType);
1322 bitStream->Serialize(writeToBitstream,targetHandle);
1323 bitStream->Serialize(writeToBitstream,targetRating);
1324 }
1325
PrevalidateInput(void)1326 bool Ranking_UpdateRating::PrevalidateInput( void )
1327 {
1328 if (!ValidateRequiredText(&titleName)) return false;
1329 if (!ValidateRequiredText(&gameType)) return false;
1330 if (!ValidateHandle(&targetHandle)) return false;
1331
1332 return true;
1333 }
1334
Serialize(bool writeToBitstream,bool serializeOutput,BitStream * bitStream)1335 void Ranking_WipeRatings::Serialize( bool writeToBitstream, bool serializeOutput, BitStream *bitStream )
1336 {
1337 SerializeBase(writeToBitstream, serializeOutput, bitStream);
1338 bitStream->Serialize(writeToBitstream,titleName);
1339 bitStream->Serialize(writeToBitstream,gameType);
1340 }
1341
PrevalidateInput(void)1342 bool Ranking_WipeRatings::PrevalidateInput( void )
1343 {
1344
1345 if (!ValidateRequiredText(&titleName)) return false;
1346 if (!ValidateRequiredText(&gameType)) return false;
1347 return true;
1348 }
1349
Serialize(bool writeToBitstream,bool serializeOutput,BitStream * bitStream)1350 void Ranking_GetRating::Serialize( bool writeToBitstream, bool serializeOutput, BitStream *bitStream )
1351 {
1352 SerializeBase(writeToBitstream, serializeOutput, bitStream);
1353 bitStream->Serialize(writeToBitstream,titleName);
1354 bitStream->Serialize(writeToBitstream,gameType);
1355 bitStream->Serialize(writeToBitstream,targetHandle);
1356 if (serializeOutput)
1357 bitStream->Serialize(writeToBitstream,currentRating);
1358 }
1359
PrevalidateInput(void)1360 bool Ranking_GetRating::PrevalidateInput( void )
1361 {
1362
1363 if (!ValidateRequiredText(&titleName)) return false;
1364 if (!ValidateRequiredText(&gameType)) return false;
1365 if (!ValidateHandle(&targetHandle)) return false;
1366 return true;
1367 }
1368
Serialize(bool writeToBitstream,bool serializeOutput,BitStream * bitStream)1369 void Clans_Create::Serialize( bool writeToBitstream, bool serializeOutput, BitStream *bitStream )
1370 {
1371 SerializeBase(writeToBitstream, serializeOutput, bitStream);
1372 bitStream->Serialize(writeToBitstream,clanHandle);
1373 bitStream->Serialize(writeToBitstream,failIfAlreadyInClan);
1374 bitStream->Serialize(writeToBitstream,requiresInvitationsToJoin);
1375 bitStream->Serialize(writeToBitstream,description);
1376 binaryData->Serialize(writeToBitstream,bitStream);
1377 }
1378
PrevalidateInput(void)1379 bool Clans_Create::PrevalidateInput( void )
1380 {
1381
1382 if (!ValidateHandle(&clanHandle)) return false;
1383 return true;
1384 }
1385
Serialize(bool writeToBitstream,bool serializeOutput,BitStream * bitStream)1386 void Clans_SetProperties::Serialize( bool writeToBitstream, bool serializeOutput, BitStream *bitStream )
1387 {
1388 SerializeBase(writeToBitstream, serializeOutput, bitStream);
1389 bitStream->Serialize(writeToBitstream,clanHandle);
1390 bitStream->Serialize(writeToBitstream,description);
1391 binaryData->Serialize(writeToBitstream, bitStream);
1392 }
1393
PrevalidateInput(void)1394 bool Clans_SetProperties::PrevalidateInput( void )
1395 {
1396
1397 if (!ValidateHandle(&clanHandle)) return false;
1398 if (!ValidateBinary(binaryData)) return false;
1399 return true;
1400 }
1401
Serialize(bool writeToBitstream,bool serializeOutput,BitStream * bitStream)1402 void Clans_GetProperties::Serialize( bool writeToBitstream, bool serializeOutput, BitStream *bitStream )
1403 {
1404 SerializeBase(writeToBitstream, serializeOutput, bitStream);
1405 bitStream->Serialize(writeToBitstream,clanHandle);
1406 if (serializeOutput)
1407 {
1408 bitStream->Serialize(writeToBitstream,description);
1409 binaryData->Serialize(writeToBitstream, bitStream);
1410 }
1411 }
1412
PrevalidateInput(void)1413 bool Clans_GetProperties::PrevalidateInput( void )
1414 {
1415
1416 if (!ValidateHandle(&clanHandle)) return false;
1417 return true;
1418 }
1419
Serialize(bool writeToBitstream,bool serializeOutput,BitStream * bitStream)1420 void Clans_SetMyMemberProperties::Serialize( bool writeToBitstream, bool serializeOutput, BitStream *bitStream )
1421 {
1422 SerializeBase(writeToBitstream, serializeOutput, bitStream);
1423 bitStream->Serialize(writeToBitstream,clanHandle);
1424 bitStream->Serialize(writeToBitstream,description);
1425 binaryData->Serialize(writeToBitstream, bitStream);
1426 }
1427
PrevalidateInput(void)1428 bool Clans_SetMyMemberProperties::PrevalidateInput( void )
1429 {
1430
1431 if (!ValidateHandle(&clanHandle)) return false;
1432 if (!ValidateBinary(binaryData)) return false;
1433 return true;
1434 }
1435
Serialize(bool writeToBitstream,bool serializeOutput,BitStream * bitStream)1436 void Clans_GrantLeader::Serialize( bool writeToBitstream, bool serializeOutput, BitStream *bitStream )
1437 {
1438 SerializeBase(writeToBitstream, serializeOutput, bitStream);
1439 bitStream->Serialize(writeToBitstream,clanHandle);
1440 bitStream->Serialize(writeToBitstream,targetHandle);
1441 }
1442
PrevalidateInput(void)1443 bool Clans_GrantLeader::PrevalidateInput( void )
1444 {
1445
1446 if (!ValidateHandle(&clanHandle)) return false;
1447 if (!ValidateHandle(&targetHandle)) return false;
1448 return true;
1449 }
1450
Serialize(bool writeToBitstream,bool serializeOutput,BitStream * bitStream)1451 void Clans_SetSubleaderStatus::Serialize( bool writeToBitstream, bool serializeOutput, BitStream *bitStream )
1452 {
1453 SerializeBase(writeToBitstream, serializeOutput, bitStream);
1454 bitStream->Serialize(writeToBitstream,clanHandle);
1455 bitStream->Serialize(writeToBitstream,targetHandle);
1456 bitStream->Serialize(writeToBitstream,setToSubleader);
1457 }
1458
PrevalidateInput(void)1459 bool Clans_SetSubleaderStatus::PrevalidateInput( void )
1460 {
1461
1462 if (!ValidateHandle(&clanHandle)) return false;
1463 if (!ValidateHandle(&targetHandle)) return false;
1464 return true;
1465 }
1466
Serialize(bool writeToBitstream,bool serializeOutput,BitStream * bitStream)1467 void Clans_SetMemberRank::Serialize( bool writeToBitstream, bool serializeOutput, BitStream *bitStream )
1468 {
1469 SerializeBase(writeToBitstream, serializeOutput, bitStream);
1470 bitStream->Serialize(writeToBitstream,clanHandle);
1471 bitStream->Serialize(writeToBitstream,targetHandle);
1472 bitStream->Serialize(writeToBitstream,newRank);
1473 }
1474
PrevalidateInput(void)1475 bool Clans_SetMemberRank::PrevalidateInput( void )
1476 {
1477
1478 if (!ValidateHandle(&clanHandle)) return false;
1479 if (!ValidateHandle(&targetHandle)) return false;
1480 return true;
1481 }
1482
Serialize(bool writeToBitstream,bool serializeOutput,BitStream * bitStream)1483 void Clans_GetMemberProperties::Serialize( bool writeToBitstream, bool serializeOutput, BitStream *bitStream )
1484 {
1485 SerializeBase(writeToBitstream, serializeOutput, bitStream);
1486 bitStream->Serialize(writeToBitstream,clanHandle);
1487 bitStream->Serialize(writeToBitstream,targetHandle);
1488 if (serializeOutput)
1489 {
1490 bitStream->Serialize(writeToBitstream,description);
1491 bitStream->Serialize(writeToBitstream,rank);
1492 binaryData->Serialize(writeToBitstream,bitStream);
1493 bitStream->Serialize(writeToBitstream,isSubleader);
1494 bitStream->Serialize(writeToBitstream,clanMemberState);
1495 bitStream->Serialize(writeToBitstream,banReason);
1496 }
1497 }
1498
PrevalidateInput(void)1499 bool Clans_GetMemberProperties::PrevalidateInput( void )
1500 {
1501
1502 if (!ValidateHandle(&clanHandle)) return false;
1503 return true;
1504 }
1505
Serialize(bool writeToBitstream,bool serializeOutput,BitStream * bitStream)1506 void Clans_ChangeHandle::Serialize( bool writeToBitstream, bool serializeOutput, BitStream *bitStream )
1507 {
1508 SerializeBase(writeToBitstream, serializeOutput, bitStream);
1509 bitStream->Serialize(writeToBitstream,oldClanHandle);
1510 bitStream->Serialize(writeToBitstream,newClanHandle);
1511 }
1512
PrevalidateInput(void)1513 bool Clans_ChangeHandle::PrevalidateInput( void )
1514 {
1515
1516 if (!ValidateHandle(&oldClanHandle)) return false;
1517 if (!ValidateHandle(&newClanHandle)) return false;
1518 if (oldClanHandle.StrICmp(newClanHandle)==0)
1519 {
1520 resultCode=L2RC_Clans_ChangeHandle_HANDLE_NOT_CHANGED;
1521 return false;
1522 }
1523 return true;
1524 }
1525
Serialize(bool writeToBitstream,bool serializeOutput,BitStream * bitStream)1526 void Clans_Leave::Serialize( bool writeToBitstream, bool serializeOutput, BitStream *bitStream )
1527 {
1528 SerializeBase(writeToBitstream, serializeOutput, bitStream);
1529 bitStream->Serialize(writeToBitstream,clanHandle);
1530 bitStream->Serialize(writeToBitstream,dissolveIfClanLeader);
1531 bitStream->Serialize(writeToBitstream,subject);
1532 bitStream->Serialize(writeToBitstream,body);
1533 binaryData->Serialize(writeToBitstream, bitStream);
1534 if (serializeOutput)
1535 {
1536 bitStream->Serialize(writeToBitstream,wasDissolved);
1537 bitStream->Serialize(writeToBitstream,newClanLeader);
1538 }
1539 }
1540
PrevalidateInput(void)1541 bool Clans_Leave::PrevalidateInput( void )
1542 {
1543 if (!ValidateHandle(&clanHandle)) return false;
1544 return true;
1545 }
1546
Serialize(bool writeToBitstream,bool serializeOutput,BitStream * bitStream)1547 void Clans_Get::Serialize( bool writeToBitstream, bool serializeOutput, BitStream *bitStream )
1548 {
1549 SerializeBase(writeToBitstream, serializeOutput, bitStream);
1550 if (serializeOutput)
1551 {
1552 unsigned short listSize = (unsigned short) clans.Size();
1553 bitStream->SerializeCompressed(writeToBitstream, listSize);
1554 for (unsigned int i=0; i < listSize; i++)
1555 {
1556 ClanInfo obj;
1557 if (writeToBitstream)
1558 {
1559 clans[i].Serialize(writeToBitstream, bitStream);
1560 }
1561 else
1562 {
1563 obj.Serialize(writeToBitstream, bitStream);
1564 clans.Insert(obj, __FILE__, __LINE__);
1565 }
1566 }
1567 }
1568 }
1569
Serialize(bool writeToBitstream,bool serializeOutput,BitStream * bitStream)1570 void Clans_SendJoinInvitation::Serialize( bool writeToBitstream, bool serializeOutput, BitStream *bitStream )
1571 {
1572 SerializeBase(writeToBitstream, serializeOutput, bitStream);
1573 bitStream->Serialize(writeToBitstream,clanHandle);
1574 bitStream->Serialize(writeToBitstream,targetHandle);
1575 bitStream->Serialize(writeToBitstream,subject);
1576 bitStream->Serialize(writeToBitstream,body);
1577 bitStream->Serialize(writeToBitstream,emailStatus);
1578 binaryData->Serialize(writeToBitstream, bitStream);
1579 }
1580
PrevalidateInput(void)1581 bool Clans_SendJoinInvitation::PrevalidateInput( void )
1582 {
1583
1584 if (!ValidateHandle(&clanHandle)) return false;
1585 if (!ValidateHandle(&targetHandle)) return false;
1586 if (!ValidateRequiredText(&subject) && !ValidateRequiredText(&body)) return false;
1587 return true;
1588 }
1589
Serialize(bool writeToBitstream,bool serializeOutput,BitStream * bitStream)1590 void Clans_WithdrawJoinInvitation::Serialize( bool writeToBitstream, bool serializeOutput, BitStream *bitStream )
1591 {
1592 SerializeBase(writeToBitstream, serializeOutput, bitStream);
1593 bitStream->Serialize(writeToBitstream,clanHandle);
1594 bitStream->Serialize(writeToBitstream,targetHandle);
1595 bitStream->Serialize(writeToBitstream,subject);
1596 bitStream->Serialize(writeToBitstream,body);
1597 bitStream->Serialize(writeToBitstream,emailStatus);
1598 binaryData->Serialize(writeToBitstream, bitStream);
1599 }
1600
PrevalidateInput(void)1601 bool Clans_WithdrawJoinInvitation::PrevalidateInput( void )
1602 {
1603
1604 if (!ValidateHandle(&clanHandle)) return false;
1605 if (!ValidateHandle(&targetHandle)) return false;
1606 if (!ValidateRequiredText(&subject) && !ValidateRequiredText(&body)) return false;
1607 return true;
1608 }
1609
Serialize(bool writeToBitstream,bool serializeOutput,BitStream * bitStream)1610 void Clans_AcceptJoinInvitation::Serialize( bool writeToBitstream, bool serializeOutput, BitStream *bitStream )
1611 {
1612 SerializeBase(writeToBitstream, serializeOutput, bitStream);
1613 bitStream->Serialize(writeToBitstream,clanHandle);
1614 bitStream->Serialize(writeToBitstream,subject);
1615 bitStream->Serialize(writeToBitstream,body);
1616 bitStream->Serialize(writeToBitstream,emailStatus);
1617 binaryData->Serialize(writeToBitstream, bitStream);
1618 bitStream->Serialize(writeToBitstream,failIfAlreadyInClan);
1619 binaryData->Serialize(writeToBitstream, bitStream);
1620 }
1621
PrevalidateInput(void)1622 bool Clans_AcceptJoinInvitation::PrevalidateInput( void )
1623 {
1624
1625 if (!ValidateHandle(&clanHandle)) return false;
1626 if (!ValidateRequiredText(&subject) && !ValidateRequiredText(&body)) return false;
1627 return true;
1628 }
1629
Serialize(bool writeToBitstream,bool serializeOutput,BitStream * bitStream)1630 void Clans_RejectJoinInvitation::Serialize( bool writeToBitstream, bool serializeOutput, BitStream *bitStream )
1631 {
1632 SerializeBase(writeToBitstream, serializeOutput, bitStream);
1633 bitStream->Serialize(writeToBitstream,subject);
1634 bitStream->Serialize(writeToBitstream,body);
1635 bitStream->Serialize(writeToBitstream,emailStatus);
1636 binaryData->Serialize(writeToBitstream, bitStream);
1637 bitStream->Serialize(writeToBitstream,clanHandle);
1638 }
1639
PrevalidateInput(void)1640 bool Clans_RejectJoinInvitation::PrevalidateInput( void )
1641 {
1642
1643 if (!ValidateHandle(&clanHandle)) return false;
1644 if (!ValidateRequiredText(&subject) && !ValidateRequiredText(&body)) return false;
1645 return true;
1646 }
1647
Serialize(bool writeToBitstream,bool serializeOutput,BitStream * bitStream)1648 void Clans_DownloadInvitationList::Serialize( bool writeToBitstream, bool serializeOutput, BitStream *bitStream )
1649 {
1650 SerializeBase(writeToBitstream, serializeOutput, bitStream);
1651 if (serializeOutput)
1652 {
1653 unsigned short listSize = (unsigned short) invitationsSentToMe.Size();
1654 bitStream->SerializeCompressed(writeToBitstream, listSize);
1655 for (unsigned int i=0; i < listSize; i++)
1656 {
1657 OpenInvite obj;
1658 if (writeToBitstream)
1659 {
1660 invitationsSentToMe[i].Serialize(writeToBitstream, bitStream);
1661 }
1662 else
1663 {
1664 obj.Serialize(writeToBitstream, bitStream);
1665 invitationsSentToMe.Insert(obj, __FILE__, __LINE__);
1666 }
1667 }
1668
1669 listSize = (unsigned short) usersThatHaveAnInvitationFromClansThatIAmAMemberOf.Size();
1670 bitStream->SerializeCompressed(writeToBitstream, listSize);
1671 for (unsigned int i=0; i < listSize; i++)
1672 {
1673 if (writeToBitstream)
1674 {
1675 usersThatHaveAnInvitationFromClansThatIAmAMemberOf[i].Serialize(writeToBitstream, bitStream);
1676 }
1677 else
1678 {
1679 ClanJoinInvite obj;
1680 obj.Serialize(writeToBitstream, bitStream);
1681 usersThatHaveAnInvitationFromClansThatIAmAMemberOf.Insert(obj, __FILE__, __LINE__);
1682 }
1683 }
1684 }
1685 }
1686
Serialize(bool writeToBitstream,bool serializeOutput,BitStream * bitStream)1687 void Clans_SendJoinRequest::Serialize( bool writeToBitstream, bool serializeOutput, BitStream *bitStream )
1688 {
1689 SerializeBase(writeToBitstream, serializeOutput, bitStream);
1690 bitStream->Serialize(writeToBitstream,clanHandle);
1691 bitStream->Serialize(writeToBitstream,subject);
1692 bitStream->Serialize(writeToBitstream,body);
1693 bitStream->Serialize(writeToBitstream,emailStatus);
1694 binaryData->Serialize(writeToBitstream, bitStream);
1695 if (serializeOutput)
1696 {
1697 bitStream->Serialize(writeToBitstream,clanJoined);
1698 }
1699 }
1700
PrevalidateInput(void)1701 bool Clans_SendJoinRequest::PrevalidateInput( void )
1702 {
1703
1704 if (!ValidateHandle(&clanHandle)) return false;
1705 if (!ValidateRequiredText(&subject) && !ValidateRequiredText(&body)) return false;
1706 return true;
1707 }
1708
Serialize(bool writeToBitstream,bool serializeOutput,BitStream * bitStream)1709 void Clans_WithdrawJoinRequest::Serialize( bool writeToBitstream, bool serializeOutput, BitStream *bitStream )
1710 {
1711 SerializeBase(writeToBitstream, serializeOutput, bitStream);
1712 bitStream->Serialize(writeToBitstream,clanHandle);
1713 bitStream->Serialize(writeToBitstream,subject);
1714 bitStream->Serialize(writeToBitstream,body);
1715 bitStream->Serialize(writeToBitstream,emailStatus);
1716 binaryData->Serialize(writeToBitstream, bitStream);
1717 }
1718
PrevalidateInput(void)1719 bool Clans_WithdrawJoinRequest::PrevalidateInput( void )
1720 {
1721
1722 if (!ValidateHandle(&clanHandle)) return false;
1723 if (!ValidateRequiredText(&subject) && !ValidateRequiredText(&body)) return false;
1724 return true;
1725 }
1726
Serialize(bool writeToBitstream,bool serializeOutput,BitStream * bitStream)1727 void Clans_AcceptJoinRequest::Serialize( bool writeToBitstream, bool serializeOutput, BitStream *bitStream )
1728 {
1729 SerializeBase(writeToBitstream, serializeOutput, bitStream);
1730 bitStream->Serialize(writeToBitstream,clanHandle);
1731 bitStream->Serialize(writeToBitstream,subject);
1732 bitStream->Serialize(writeToBitstream,body);
1733 bitStream->Serialize(writeToBitstream,emailStatus);
1734 binaryData->Serialize(writeToBitstream, bitStream);
1735 bitStream->Serialize(writeToBitstream,requestingUserHandle);
1736 bitStream->Serialize(writeToBitstream,failIfAlreadyInClan);
1737 }
1738
PrevalidateInput(void)1739 bool Clans_AcceptJoinRequest::PrevalidateInput( void )
1740 {
1741 if (!ValidateHandle(&clanHandle)) return false;
1742 if (!ValidateHandle(&requestingUserHandle)) return false;
1743 if (!ValidateRequiredText(&subject) && !ValidateRequiredText(&body)) return false;
1744 return true;
1745 }
1746
Serialize(bool writeToBitstream,bool serializeOutput,BitStream * bitStream)1747 void Clans_RejectJoinRequest::Serialize( bool writeToBitstream, bool serializeOutput, BitStream *bitStream )
1748 {
1749 SerializeBase(writeToBitstream, serializeOutput, bitStream);
1750 bitStream->Serialize(writeToBitstream,clanHandle);
1751 bitStream->Serialize(writeToBitstream,subject);
1752 bitStream->Serialize(writeToBitstream,body);
1753 bitStream->Serialize(writeToBitstream,emailStatus);
1754 binaryData->Serialize(writeToBitstream, bitStream);
1755 bitStream->Serialize(writeToBitstream,requestingUserHandle);
1756 }
1757
PrevalidateInput(void)1758 bool Clans_RejectJoinRequest::PrevalidateInput( void )
1759 {
1760
1761 if (!ValidateHandle(&clanHandle)) return false;
1762 if (!ValidateHandle(&requestingUserHandle)) return false;
1763 if (!ValidateRequiredText(&subject) && !ValidateRequiredText(&body)) return false;
1764 return true;
1765 }
1766
Serialize(bool writeToBitstream,bool serializeOutput,BitStream * bitStream)1767 void Clans_DownloadRequestList::Serialize( bool writeToBitstream, bool serializeOutput, BitStream *bitStream )
1768 {
1769 SerializeBase(writeToBitstream, serializeOutput, bitStream);
1770 if (serializeOutput)
1771 {
1772 unsigned short listSize = (unsigned short) joinRequestsToMyClan.Size();
1773 bitStream->SerializeCompressed(writeToBitstream, listSize);
1774 for (unsigned int i=0; i < listSize; i++)
1775 {
1776 ClanJoinRequest obj;
1777 if (writeToBitstream)
1778 {
1779 joinRequestsToMyClan[i].Serialize(writeToBitstream, bitStream);
1780 }
1781 else
1782 {
1783 obj.Serialize(writeToBitstream, bitStream);
1784 joinRequestsToMyClan.Insert(obj, __FILE__, __LINE__);
1785 }
1786 }
1787
1788 listSize = (unsigned short) joinRequestsFromMe.Size();
1789 bitStream->SerializeCompressed(writeToBitstream, listSize);
1790 for (unsigned int i=0; i < listSize; i++)
1791 {
1792 ClanJoinRequest obj;
1793 if (writeToBitstream)
1794 {
1795 joinRequestsFromMe[i].Serialize(writeToBitstream, bitStream);
1796 }
1797 else
1798 {
1799 obj.Serialize(writeToBitstream, bitStream);
1800 joinRequestsFromMe.Insert(obj, __FILE__, __LINE__);
1801 }
1802 }
1803 }
1804 }
1805
Serialize(bool writeToBitstream,bool serializeOutput,BitStream * bitStream)1806 void Clans_KickAndBlacklistUser::Serialize( bool writeToBitstream, bool serializeOutput, BitStream *bitStream )
1807 {
1808 SerializeBase(writeToBitstream, serializeOutput, bitStream);
1809 bitStream->Serialize(writeToBitstream,clanHandle);
1810 bitStream->Serialize(writeToBitstream,subject);
1811 bitStream->Serialize(writeToBitstream,body);
1812 bitStream->Serialize(writeToBitstream,targetHandle);
1813 bitStream->Serialize(writeToBitstream,kick);
1814 bitStream->Serialize(writeToBitstream,blacklist);
1815 bitStream->Serialize(writeToBitstream,reason);
1816 bitStream->Serialize(writeToBitstream,emailStatus);
1817 binaryData->Serialize(writeToBitstream, bitStream);
1818 }
1819
PrevalidateInput(void)1820 bool Clans_KickAndBlacklistUser::PrevalidateInput( void )
1821 {
1822
1823 if (!ValidateHandle(&clanHandle)) return false;
1824 if (!ValidateHandle(&targetHandle)) return false;
1825 if (!ValidateRequiredText(&subject) && !ValidateRequiredText(&body)) return false;
1826 if (!ValidateRequiredText(&reason)) return false;
1827 return true;
1828 }
1829
Serialize(bool writeToBitstream,bool serializeOutput,BitStream * bitStream)1830 void Clans_UnblacklistUser::Serialize( bool writeToBitstream, bool serializeOutput, BitStream *bitStream )
1831 {
1832 SerializeBase(writeToBitstream, serializeOutput, bitStream);
1833 bitStream->Serialize(writeToBitstream,clanHandle);
1834 bitStream->Serialize(writeToBitstream,subject);
1835 bitStream->Serialize(writeToBitstream,body);
1836 bitStream->Serialize(writeToBitstream,targetHandle);
1837 bitStream->Serialize(writeToBitstream,emailStatus);
1838 binaryData->Serialize(writeToBitstream, bitStream);
1839 }
1840
PrevalidateInput(void)1841 bool Clans_UnblacklistUser::PrevalidateInput( void )
1842 {
1843
1844 if (!ValidateHandle(&clanHandle)) return false;
1845 if (!ValidateHandle(&targetHandle)) return false;
1846 if (!ValidateRequiredText(&subject) && !ValidateRequiredText(&body)) return false;
1847 return true;
1848 }
1849
Serialize(bool writeToBitstream,bool serializeOutput,BitStream * bitStream)1850 void Clans_GetBlacklist::Serialize( bool writeToBitstream, bool serializeOutput, BitStream *bitStream )
1851 {
1852 SerializeBase(writeToBitstream, serializeOutput, bitStream);
1853 bitStream->Serialize(writeToBitstream,clanHandle);
1854 if (serializeOutput)
1855 {
1856 unsigned short listSize = (unsigned short) blacklistedUsers.Size();
1857 bitStream->SerializeCompressed(writeToBitstream, listSize);
1858 for (unsigned int i=0; i < listSize; i++)
1859 {
1860 RakString obj;
1861 if (writeToBitstream)
1862 {
1863 bitStream->Serialize(writeToBitstream, blacklistedUsers[i]);
1864 }
1865 else
1866 {
1867 bitStream->Serialize(writeToBitstream, obj);
1868 blacklistedUsers.Insert(obj, __FILE__, __LINE__);
1869 }
1870 }
1871 }
1872 }
1873
PrevalidateInput(void)1874 bool Clans_GetBlacklist::PrevalidateInput( void )
1875 {
1876
1877 for (unsigned int i=0; i < blacklistedUsers.Size(); i++)
1878 if (!ValidateHandle(&blacklistedUsers[i])) return false;
1879 return true;
1880 }
1881
Serialize(bool writeToBitstream,bool serializeOutput,BitStream * bitStream)1882 void Clans_GetMembers::Serialize( bool writeToBitstream, bool serializeOutput, BitStream *bitStream )
1883 {
1884 SerializeBase(writeToBitstream, serializeOutput, bitStream);
1885 bitStream->Serialize(writeToBitstream,clanHandle);
1886 if (serializeOutput)
1887 {
1888 bitStream->Serialize(writeToBitstream,clanLeader);
1889
1890 unsigned short listSize = (unsigned short) clanMembersOtherThanLeader.Size();
1891 bitStream->SerializeCompressed(writeToBitstream, listSize);
1892 for (unsigned int i=0; i < listSize; i++)
1893 {
1894 RakString obj;
1895 if (writeToBitstream)
1896 {
1897 bitStream->Serialize(writeToBitstream, clanMembersOtherThanLeader[i]);
1898 }
1899 else
1900 {
1901 bitStream->Serialize(writeToBitstream, obj);
1902 clanMembersOtherThanLeader.Insert(obj, __FILE__, __LINE__);
1903 }
1904 }
1905 }
1906 }
1907
PrevalidateInput(void)1908 bool Clans_GetMembers::PrevalidateInput( void )
1909 {
1910
1911 if (!ValidateHandle(&clanHandle)) return false;
1912 return true;
1913 }
1914
Serialize(bool writeToBitstream,bool serializeOutput,BitStream * bitStream)1915 void Clans_GetList::Serialize( bool writeToBitstream, bool serializeOutput, BitStream *bitStream )
1916 {
1917 SerializeBase(writeToBitstream, serializeOutput, bitStream);
1918 if (serializeOutput)
1919 {
1920 unsigned short listSize = (unsigned short) clanNames.Size();
1921 bitStream->SerializeCompressed(writeToBitstream, listSize);
1922 for (unsigned int i=0; i < listSize; i++)
1923 {
1924 RakString obj;
1925 if (writeToBitstream)
1926 {
1927 bitStream->Serialize(writeToBitstream, clanNames[i]);
1928 }
1929 else
1930 {
1931 bitStream->Serialize(writeToBitstream, obj);
1932 clanNames.Insert(obj, __FILE__, __LINE__);
1933 }
1934 }
1935 }
1936 }
1937
Serialize(bool writeToBitstream,bool serializeOutput,BitStream * bitStream)1938 void Clans_CreateBoard::Serialize( bool writeToBitstream, bool serializeOutput, BitStream *bitStream )
1939 {
1940 SerializeBase(writeToBitstream, serializeOutput, bitStream);
1941 bitStream->Serialize(writeToBitstream,clanHandle);
1942 bitStream->Serialize(writeToBitstream,clanBoardName);
1943 bitStream->Serialize(writeToBitstream,allowPublicReads);
1944 bitStream->Serialize(writeToBitstream,allowPublicWrites);
1945 bitStream->Serialize(writeToBitstream,description);
1946 binaryData->Serialize(writeToBitstream, bitStream);
1947 }
1948
PrevalidateInput(void)1949 bool Clans_CreateBoard::PrevalidateInput( void )
1950 {
1951 if (!ValidateHandle(&clanHandle)) return false;
1952 if (!ValidateHandle(&clanBoardName)) return false;
1953 return true;
1954 }
1955
Serialize(bool writeToBitstream,bool serializeOutput,BitStream * bitStream)1956 void Clans_DestroyBoard::Serialize( bool writeToBitstream, bool serializeOutput, BitStream *bitStream )
1957 {
1958 SerializeBase(writeToBitstream, serializeOutput, bitStream);
1959 bitStream->Serialize(writeToBitstream,clanHandle);
1960 bitStream->Serialize(writeToBitstream,clanBoardName);
1961 }
1962
PrevalidateInput(void)1963 bool Clans_DestroyBoard::PrevalidateInput( void )
1964 {
1965
1966 if (!ValidateHandle(&clanHandle)) return false;
1967 if (!ValidateHandle(&clanBoardName)) return false;
1968 return true;
1969 }
1970
Serialize(bool writeToBitstream,bool serializeOutput,BitStream * bitStream)1971 void Clans_CreateNewTopic::Serialize( bool writeToBitstream, bool serializeOutput, BitStream *bitStream )
1972 {
1973 SerializeBase(writeToBitstream, serializeOutput, bitStream);
1974 bitStream->Serialize(writeToBitstream,clanHandle);
1975 bitStream->Serialize(writeToBitstream,clanBoardName);
1976 bitStream->Serialize(writeToBitstream,body);
1977 bitStream->Serialize(writeToBitstream,subject);
1978 binaryData->Serialize(writeToBitstream, bitStream);
1979
1980 if (serializeOutput)
1981 {
1982 bitStream->Serialize(writeToBitstream,postId);
1983 }
1984 }
1985
PrevalidateInput(void)1986 bool Clans_CreateNewTopic::PrevalidateInput( void )
1987 {
1988
1989 if (!ValidateHandle(&clanHandle)) return false;
1990 if (!ValidateHandle(&clanBoardName)) return false;
1991 if (!ValidateRequiredText(&subject) && !ValidateRequiredText(&body)) return false;
1992 if (!ValidateBinary(binaryData)) return false;
1993 return true;
1994 }
1995
Serialize(bool writeToBitstream,bool serializeOutput,BitStream * bitStream)1996 void Clans_ReplyToTopic::Serialize( bool writeToBitstream, bool serializeOutput, BitStream *bitStream )
1997 {
1998 SerializeBase(writeToBitstream, serializeOutput, bitStream);
1999 bitStream->Serialize(writeToBitstream,postId);
2000 bitStream->Serialize(writeToBitstream,body);
2001 bitStream->Serialize(writeToBitstream,subject);
2002 binaryData->Serialize(writeToBitstream, bitStream);
2003 }
2004
PrevalidateInput(void)2005 bool Clans_ReplyToTopic::PrevalidateInput( void )
2006 {
2007
2008 if (!ValidateRequiredText(&subject) && !ValidateRequiredText(&body)) return false;
2009 if (!ValidateBinary(binaryData)) return false;
2010 return true;
2011 }
2012
Serialize(bool writeToBitstream,bool serializeOutput,BitStream * bitStream)2013 void Clans_RemovePost::Serialize( bool writeToBitstream, bool serializeOutput, BitStream *bitStream )
2014 {
2015 SerializeBase(writeToBitstream, serializeOutput, bitStream);
2016 bitStream->Serialize(writeToBitstream,postId);
2017 bitStream->Serialize(writeToBitstream,removeEntireTopic);
2018 }
2019
Serialize(bool writeToBitstream,bool serializeOutput,BitStream * bitStream)2020 void Clans_GetBoards::Serialize( bool writeToBitstream, bool serializeOutput, BitStream *bitStream )
2021 {
2022 SerializeBase(writeToBitstream, serializeOutput, bitStream);
2023 bitStream->Serialize(writeToBitstream,clanHandle);
2024 if (serializeOutput)
2025 {
2026 unsigned short listSize = (unsigned short) clanBoardsNames.Size();
2027 bitStream->SerializeCompressed(writeToBitstream, listSize);
2028 for (unsigned int i=0; i < listSize; i++)
2029 {
2030 RakString obj;
2031 if (writeToBitstream)
2032 {
2033 bitStream->Serialize(writeToBitstream, clanBoardsNames[i]);
2034 }
2035 else
2036 {
2037 bitStream->Serialize(writeToBitstream, obj);
2038 clanBoardsNames.Insert(obj, __FILE__, __LINE__);
2039 }
2040 }
2041 }
2042 }
2043
PrevalidateInput(void)2044 bool Clans_GetBoards::PrevalidateInput( void )
2045 {
2046
2047 if (!ValidateHandle(&clanHandle)) return false;
2048 return true;
2049 }
2050
Serialize(bool writeToBitstream,bool serializeOutput,BitStream * bitStream)2051 void Clans_GetTopics::Serialize( bool writeToBitstream, bool serializeOutput, BitStream *bitStream )
2052 {
2053 SerializeBase(writeToBitstream, serializeOutput, bitStream);
2054 bitStream->Serialize(writeToBitstream,clanHandle);
2055 bitStream->Serialize(writeToBitstream,clanBoardName);
2056 }
2057
PrevalidateInput(void)2058 bool Clans_GetTopics::PrevalidateInput( void )
2059 {
2060
2061 if (!ValidateHandle(&clanHandle)) return false;
2062 if (!ValidateHandle(&clanBoardName)) return false;
2063 return true;
2064 }
2065
Serialize(bool writeToBitstream,bool serializeOutput,BitStream * bitStream)2066 void Clans_GetPosts::Serialize( bool writeToBitstream, bool serializeOutput, BitStream *bitStream )
2067 {
2068 SerializeBase(writeToBitstream, serializeOutput, bitStream);
2069 bitStream->Serialize(writeToBitstream,postId);
2070 }
2071
PrevalidateInput(void)2072 bool Clans_GetPosts::PrevalidateInput( void )
2073 {
2074
2075 return true;
2076 }
Serialize(bool writeToBitstream,bool serializeOutput,RakNet::BitStream * bitStream)2077 void RakNet::Notification_Client_RemoteLogin::Serialize( bool writeToBitstream, bool serializeOutput, RakNet::BitStream *bitStream )
2078 {
2079 SerializeBase(writeToBitstream, serializeOutput, bitStream);
2080 bitStream->Serialize(writeToBitstream, handle);
2081 }
Serialize(bool writeToBitstream,bool serializeOutput,RakNet::BitStream * bitStream)2082 void RakNet::Notification_Client_IgnoreStatus::Serialize( bool writeToBitstream, bool serializeOutput, RakNet::BitStream *bitStream )
2083 {
2084 SerializeBase(writeToBitstream, serializeOutput, bitStream);
2085 bitStream->Serialize(writeToBitstream, nowIgnored);
2086 bitStream->Serialize(writeToBitstream, otherHandle);
2087 }
2088
Serialize(bool writeToBitstream,bool serializeOutput,RakNet::BitStream * bitStream)2089 void RakNet::Notification_Friends_StatusChange::Serialize( bool writeToBitstream, bool serializeOutput, RakNet::BitStream *bitStream )
2090 {
2091 SerializeBase(writeToBitstream, serializeOutput, bitStream);
2092 bitStream->Serialize(writeToBitstream, op);
2093 bitStream->Serialize(writeToBitstream, otherHandle);
2094 bitStream->Serialize(writeToBitstream, subject);
2095 bitStream->Serialize(writeToBitstream, body);
2096 presence.Serialize(bitStream,writeToBitstream);
2097 }
2098
Serialize(bool writeToBitstream,bool serializeOutput,RakNet::BitStream * bitStream)2099 void RakNet::Notification_Friends_PresenceUpdate::Serialize( bool writeToBitstream, bool serializeOutput, RakNet::BitStream *bitStream )
2100 {
2101 SerializeBase(writeToBitstream, serializeOutput, bitStream);
2102 newPresence.Serialize(bitStream,writeToBitstream);
2103 bitStream->Serialize(writeToBitstream, otherHandle);
2104 }
Serialize(bool writeToBitstream,bool serializeOutput,RakNet::BitStream * bitStream)2105 void RakNet::Notification_User_ChangedHandle::Serialize( bool writeToBitstream, bool serializeOutput, RakNet::BitStream *bitStream )
2106 {
2107 SerializeBase(writeToBitstream, serializeOutput, bitStream);
2108 bitStream->Serialize(writeToBitstream, oldHandle);
2109 bitStream->Serialize(writeToBitstream, newHandle);
2110 }
2111
Serialize(bool writeToBitstream,bool serializeOutput,RakNet::BitStream * bitStream)2112 void RakNet::Notification_Friends_CreatedClan::Serialize( bool writeToBitstream, bool serializeOutput, RakNet::BitStream *bitStream )
2113 {
2114 SerializeBase(writeToBitstream, serializeOutput, bitStream);
2115 bitStream->Serialize(writeToBitstream, otherHandle);
2116 bitStream->Serialize(writeToBitstream, clanName);
2117 }
2118
Serialize(bool writeToBitstream,bool serializeOutput,RakNet::BitStream * bitStream)2119 void RakNet::Notification_Emails_Received::Serialize( bool writeToBitstream, bool serializeOutput, RakNet::BitStream *bitStream )
2120 {
2121 SerializeBase(writeToBitstream, serializeOutput, bitStream);
2122 bitStream->Serialize(writeToBitstream, sender);
2123 bitStream->Serialize(writeToBitstream, subject);
2124 bitStream->Serialize(writeToBitstream, emailId);
2125 }
2126
Serialize(bool writeToBitstream,bool serializeOutput,RakNet::BitStream * bitStream)2127 void RakNet::Notification_Clans_GrantLeader::Serialize( bool writeToBitstream, bool serializeOutput, RakNet::BitStream *bitStream )
2128 {
2129 SerializeBase(writeToBitstream, serializeOutput, bitStream);
2130 bitStream->Serialize(writeToBitstream, clanHandle);
2131 bitStream->Serialize(writeToBitstream, newLeader);
2132 bitStream->Serialize(writeToBitstream, oldLeader);
2133 }
2134
Serialize(bool writeToBitstream,bool serializeOutput,RakNet::BitStream * bitStream)2135 void RakNet::Notification_Clans_SetSubleaderStatus::Serialize( bool writeToBitstream, bool serializeOutput, RakNet::BitStream *bitStream )
2136 {
2137 SerializeBase(writeToBitstream, serializeOutput, bitStream);
2138 bitStream->Serialize(writeToBitstream, clanHandle);
2139 bitStream->Serialize(writeToBitstream, targetHandle);
2140 bitStream->Serialize(writeToBitstream, leaderHandle);
2141 bitStream->Serialize(writeToBitstream, setToSubleader);
2142 }
2143
Serialize(bool writeToBitstream,bool serializeOutput,RakNet::BitStream * bitStream)2144 void RakNet::Notification_Clans_SetMemberRank::Serialize( bool writeToBitstream, bool serializeOutput, RakNet::BitStream *bitStream )
2145 {
2146 SerializeBase(writeToBitstream, serializeOutput, bitStream);
2147 bitStream->Serialize(writeToBitstream, clanHandle);
2148 bitStream->Serialize(writeToBitstream, targetHandle);
2149 bitStream->Serialize(writeToBitstream, leaderHandle);
2150 bitStream->Serialize(writeToBitstream, newRank);
2151 }
2152
Serialize(bool writeToBitstream,bool serializeOutput,RakNet::BitStream * bitStream)2153 void RakNet::Notification_Clans_ChangeHandle::Serialize( bool writeToBitstream, bool serializeOutput, RakNet::BitStream *bitStream )
2154 {
2155 SerializeBase(writeToBitstream, serializeOutput, bitStream);
2156 bitStream->Serialize(writeToBitstream, oldClanHandle);
2157 bitStream->Serialize(writeToBitstream, newClanHandle);
2158 bitStream->Serialize(writeToBitstream, leaderHandle);
2159 }
2160
Serialize(bool writeToBitstream,bool serializeOutput,RakNet::BitStream * bitStream)2161 void RakNet::Notification_Clans_Leave::Serialize( bool writeToBitstream, bool serializeOutput, RakNet::BitStream *bitStream )
2162 {
2163 SerializeBase(writeToBitstream, serializeOutput, bitStream);
2164 bitStream->Serialize(writeToBitstream, clanHandle);
2165 bitStream->Serialize(writeToBitstream, targetHandle);
2166 }
2167
Serialize(bool writeToBitstream,bool serializeOutput,RakNet::BitStream * bitStream)2168 void RakNet::Notification_Clans_PendingJoinStatus::Serialize( bool writeToBitstream, bool serializeOutput, RakNet::BitStream *bitStream )
2169 {
2170 SerializeBase(writeToBitstream, serializeOutput, bitStream);
2171 bitStream->Serialize(writeToBitstream, clanHandle);
2172 bitStream->Serialize(writeToBitstream, sourceHandle);
2173 bitStream->Serialize(writeToBitstream, targetHandle);
2174 bitStream->Serialize(writeToBitstream, clanMemberHandle);
2175 unsigned char c1 = (unsigned char) majorOp;
2176 unsigned char c2 = (unsigned char) minorOp;
2177 bitStream->Serialize(writeToBitstream, c1);
2178 bitStream->Serialize(writeToBitstream, c2);
2179 majorOp=(Notification_Clans_PendingJoinStatus::MajorOp) c1;
2180 minorOp=(Notification_Clans_PendingJoinStatus::MinorOp) c2;
2181 }
2182
Serialize(bool writeToBitstream,bool serializeOutput,RakNet::BitStream * bitStream)2183 void RakNet::Notification_Clans_NewClanMember::Serialize( bool writeToBitstream, bool serializeOutput, RakNet::BitStream *bitStream )
2184 {
2185 SerializeBase(writeToBitstream, serializeOutput, bitStream);
2186 bitStream->Serialize(writeToBitstream, clanHandle);
2187 bitStream->Serialize(writeToBitstream, targetHandle);
2188 }
2189
Serialize(bool writeToBitstream,bool serializeOutput,RakNet::BitStream * bitStream)2190 void RakNet::Notification_Clans_KickAndBlacklistUser::Serialize( bool writeToBitstream, bool serializeOutput, RakNet::BitStream *bitStream )
2191 {
2192 SerializeBase(writeToBitstream, serializeOutput, bitStream);
2193 bitStream->Serialize(writeToBitstream, clanHandle);
2194 bitStream->Serialize(writeToBitstream, targetHandle);
2195 bitStream->Serialize(writeToBitstream, blacklistingUserHandle);
2196 bitStream->Serialize(writeToBitstream, targetHandleWasKicked);
2197 bitStream->Serialize(writeToBitstream, reason);
2198 }
2199
Serialize(bool writeToBitstream,bool serializeOutput,RakNet::BitStream * bitStream)2200 void RakNet::Notification_Clans_UnblacklistUser::Serialize( bool writeToBitstream, bool serializeOutput, RakNet::BitStream *bitStream )
2201 {
2202 SerializeBase(writeToBitstream, serializeOutput, bitStream);
2203 bitStream->Serialize(writeToBitstream, clanHandle);
2204 bitStream->Serialize(writeToBitstream, targetHandle);
2205 bitStream->Serialize(writeToBitstream, unblacklistingUserHandle);
2206 }
2207
Serialize(bool writeToBitstream,bool serializeOutput,RakNet::BitStream * bitStream)2208 void RakNet::Notification_Clans_Destroyed::Serialize( bool writeToBitstream, bool serializeOutput, RakNet::BitStream *bitStream )
2209 {
2210 SerializeBase(writeToBitstream, serializeOutput, bitStream);
2211 bitStream->Serialize(writeToBitstream, oldClanLeader);
2212 bitStream->Serialize(writeToBitstream, clanHandle);
2213 }
2214
2215
ClientImpl(Lobby2Client * client)2216 bool RakNet::Client_StartIgnore::ClientImpl( Lobby2Client *client )
2217 {
2218 (void)client;
2219 // if (resultCode==L2RC_SUCCESS)
2220 // client->AddToIgnoreList(targetHandle);
2221 return true;
2222 }
2223
ClientImpl(Lobby2Client * client)2224 bool RakNet::Client_StopIgnore::ClientImpl( Lobby2Client *client )
2225 {
2226 (void)client;
2227 // if (resultCode==L2RC_SUCCESS)
2228 // client->RemoveFromIgnoreList(targetHandle);
2229 return true;
2230 }
2231
ClientImpl(Lobby2Client * client)2232 bool RakNet::Client_GetIgnoreList::ClientImpl( Lobby2Client *client )
2233 {
2234 (void)client;
2235 // if (resultCode==L2RC_SUCCESS)
2236 // client->SetIgnoreList(ignoredHandles);
2237 return true;
2238 }