IPXADDR.CPP (24328B)
1 // 2 // Copyright 2020 Electronic Arts Inc. 3 // 4 // TiberianDawn.DLL and RedAlert.dll and corresponding source code is free 5 // software: you can redistribute it and/or modify it under the terms of 6 // the GNU General Public License as published by the Free Software Foundation, 7 // either version 3 of the License, or (at your option) any later version. 8 9 // TiberianDawn.DLL and RedAlert.dll and corresponding source code is distributed 10 // in the hope that it will be useful, but with permitted additional restrictions 11 // under Section 7 of the GPL. See the GNU General Public License in LICENSE.TXT 12 // distributed with this program. You should have received a copy of the 13 // GNU General Public License along with permitted additional restrictions 14 // with this program. If not, see https://github.com/electronicarts/CnC_Remastered_Collection 15 16 /* $Header: /CounterStrike/IPXADDR.CPP 1 3/03/97 10:24a Joe_bostic $ */ 17 /*************************************************************************** 18 ** C O N F I D E N T I A L --- W E S T W O O D S T U D I O S ** 19 *************************************************************************** 20 * * 21 * Project Name : Command & Conquer * 22 * * 23 * File Name : IPXADDR.CPP * 24 * * 25 * Programmer : Bill Randolph * 26 * * 27 * Start Date : December 19, 1994 * 28 * * 29 * Last Update : December 19, 1994 [BR] * 30 * * 31 *-------------------------------------------------------------------------* 32 * Functions: * 33 * IPXAddressClass::IPXAddressClass -- class constructor * 34 * IPXAddressClass::IPXAddressClass -- class constructor form 2 * 35 * IPXAddressClass::IPXAddressClass -- class constructor form 3 * 36 * IPXAddressClass::Set_Address -- sets the IPX address values * 37 * IPXAddressClass::Set_Address -- sets the IPX values from a header * 38 * IPXAddressClass::Get_Address -- retrieves the IPX address values * 39 * IPXAddressClass::Get_Address -- copies address into an IPX header * 40 * IPXAddressClass::Is_Broadcast -- tells if this is a broadcast address * 41 * IPXAddressClass::operator== -- overloaded comparison operator * 42 * IPXAddressClass::operator!= -- overloaded comparison operator * 43 * - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - */ 44 45 46 #include "function.h" 47 #include <stdio.h> 48 //#include <mem.h> 49 #include "ipxaddr.h" 50 51 #ifdef WINSOCK_IPX 52 #include "WSProto.h" 53 #endif //WINSOCK_IPX 54 55 56 /*************************************************************************** 57 * IPXAddressClass::IPXAddressClass -- class constructor * 58 * * 59 * This default constructor generates a broadcast address. * 60 * * 61 * INPUT: * 62 * net Network Number for this address * 63 * node Node Address for this address * 64 * * 65 * OUTPUT: * 66 * none. * 67 * * 68 * WARNINGS: * 69 * none. * 70 * * 71 * HISTORY: * 72 * 12/19/1994 BR : Created. * 73 *=========================================================================*/ 74 IPXAddressClass::IPXAddressClass(void) 75 { 76 NetworkNumber[0] = 0xff; 77 NetworkNumber[1] = 0xff; 78 NetworkNumber[2] = 0xff; 79 NetworkNumber[3] = 0xff; 80 NodeAddress[0] = 0xff; 81 NodeAddress[1] = 0xff; 82 NodeAddress[2] = 0xff; 83 NodeAddress[3] = 0xff; 84 NodeAddress[4] = 0xff; 85 NodeAddress[5] = 0xff; 86 87 } /* end of IPXAddressClass */ 88 89 90 /*************************************************************************** 91 * IPXAddressClass::IPXAddressClass -- class constructor form 2 * 92 * * 93 * INPUT: * 94 * net Network Number for this address * 95 * node Node Address for this address * 96 * * 97 * OUTPUT: * 98 * none. * 99 * * 100 * WARNINGS: * 101 * none. * 102 * * 103 * HISTORY: * 104 * 12/19/1994 BR : Created. * 105 *=========================================================================*/ 106 IPXAddressClass::IPXAddressClass(NetNumType net, NetNodeType node) 107 { 108 memcpy(NetworkNumber, net, 4); 109 memcpy(NodeAddress, node, 6); 110 111 } /* end of IPXAddressClass */ 112 113 114 /*************************************************************************** 115 * IPXAddressClass::IPXAddressClass -- class constructor form 3 * 116 * * 117 * This form of the constructor takes an IPX header as an argument. It * 118 * extracts the address from the Source address fields in the header. * 119 * * 120 * INPUT: * 121 * header Header from which to extract the address * 122 * * 123 * OUTPUT: * 124 * none. * 125 * * 126 * WARNINGS: * 127 * none. * 128 * * 129 * HISTORY: * 130 * 12/19/1994 BR : Created. * 131 *=========================================================================*/ 132 IPXAddressClass::IPXAddressClass(IPXHeaderType *header) 133 { 134 memcpy(NetworkNumber,header->SourceNetworkNumber,4); 135 memcpy(NodeAddress,header->SourceNetworkNode,6); 136 137 } /* end of IPXAddressClass */ 138 139 140 /*************************************************************************** 141 * IPXAddressClass::Set_Address -- sets the IPX address values * 142 * * 143 * INPUT: * 144 * net Network Number for this address * 145 * node Node Address for this address * 146 * * 147 * OUTPUT: * 148 * none. * 149 * * 150 * WARNINGS: * 151 * none. * 152 * * 153 * HISTORY: * 154 * 12/19/1994 BR : Created. * 155 *=========================================================================*/ 156 void IPXAddressClass::Set_Address(NetNumType net, NetNodeType node) 157 { 158 memcpy(NetworkNumber,net,4); 159 memcpy(NodeAddress,node,6); 160 161 } /* end of Set_Address */ 162 163 164 /*************************************************************************** 165 * IPXAddressClass::Set_Address -- sets the IPX values from a header * 166 * * 167 * This routine extracts the source addresses from the given IPX header. * 168 * * 169 * INPUT: * 170 * net Network Number for this address * 171 * node Node Address for this address * 172 * * 173 * OUTPUT: * 174 * none. * 175 * * 176 * WARNINGS: * 177 * none. * 178 * * 179 * HISTORY: * 180 * 12/19/1994 BR : Created. * 181 *=========================================================================*/ 182 void IPXAddressClass::Set_Address(IPXHeaderType *header) 183 { 184 #ifdef WINSOCK_IPX 185 ProtocolEnum protocol = PROTOCOL_IPX; 186 if ( PacketTransport ) protocol = PacketTransport->Get_Protocol(); 187 188 switch ( protocol ) { 189 190 case PROTOCOL_IPX: 191 memcpy(NetworkNumber,header->SourceNetworkNumber,4); 192 memcpy(NodeAddress,header->SourceNetworkNode,6); 193 break; 194 195 case PROTOCOL_UDP: 196 unsigned char *addr = (unsigned char*) header; 197 memset (NodeAddress, 0, 6); 198 memcpy (NodeAddress, addr, 4); 199 memset (NetworkNumber, 0, 4); 200 break; 201 } 202 #else //WINSOCK_IPX 203 204 if (header) { 205 memcpy(NetworkNumber,header->SourceNetworkNumber,4); 206 memcpy(NodeAddress,header->SourceNetworkNode,6); 207 } else { 208 /* 209 ** Address is meaningless when using winsock 210 */ 211 memset(NetworkNumber, 1 ,4); 212 memset(NodeAddress, 1, 6); 213 } 214 215 #endif //WINSOCK_IPX 216 217 } /* end of Set_Address */ 218 219 220 /*************************************************************************** 221 * IPXAddressClass::Get_Address -- retrieves the IPX address values * 222 * * 223 * INPUT: * 224 * net Network Number for this address * 225 * node Node Address for this address * 226 * * 227 * OUTPUT: * 228 * none. * 229 * * 230 * WARNINGS: * 231 * none. * 232 * * 233 * HISTORY: * 234 * 12/19/1994 BR : Created. * 235 *=========================================================================*/ 236 void IPXAddressClass::Get_Address(NetNumType net, NetNodeType node) 237 { 238 memcpy(net,NetworkNumber,4); 239 memcpy(node,NodeAddress,6); 240 241 } /* end of Get_Address */ 242 243 244 /*************************************************************************** 245 * IPXAddressClass::Get_Address -- copies address into an IPX header * 246 * * 247 * INPUT: * 248 * net Network Number for this address * 249 * node Node Address for this address * 250 * * 251 * OUTPUT: * 252 * none. * 253 * * 254 * WARNINGS: * 255 * none. * 256 * * 257 * HISTORY: * 258 * 12/19/1994 BR : Created. * 259 *=========================================================================*/ 260 void IPXAddressClass::Get_Address(IPXHeaderType *header) 261 { 262 memcpy(header->DestNetworkNumber,NetworkNumber,4); 263 memcpy(header->DestNetworkNode,NodeAddress,6); 264 265 } /* end of Get_Address */ 266 267 268 /*************************************************************************** 269 * IPXAddressClass::Is_Broadcast -- tells if this is a broadcast address * 270 * * 271 * INPUT: * 272 * none. * 273 * * 274 * OUTPUT: * 275 * none. * 276 * * 277 * WARNINGS: * 278 * none. * 279 * * 280 * HISTORY: * 281 * 12/19/1994 BR : Created. * 282 *=========================================================================*/ 283 int IPXAddressClass::Is_Broadcast(void) 284 { 285 if ( NetworkNumber[0] == 0xff && 286 NetworkNumber[1] == 0xff && 287 NetworkNumber[2] == 0xff && 288 NetworkNumber[3] == 0xff && 289 NodeAddress[0] == 0xff && 290 NodeAddress[1] == 0xff && 291 NodeAddress[2] == 0xff && 292 NodeAddress[3] == 0xff && 293 NodeAddress[4] == 0xff && 294 NodeAddress[5] == 0xff) { 295 return(1); 296 } 297 else { 298 return(0); 299 } 300 301 } /* end of Is_Broadcast */ 302 303 304 /*************************************************************************** 305 * IPXAddressClass::operator== -- overloaded comparison operator * 306 * * 307 * Since, if NETX isn't running, the network number on a received packet * 308 * can be bogus (all 0's), only the node address is used for comparison * 309 * purposes here. * 310 * * 311 * INPUT: * 312 * addr address to compare to * 313 * * 314 * OUTPUT: * 315 * 0 = not equal, 1 = equal * 316 * * 317 * WARNINGS: * 318 * none. * 319 * * 320 * HISTORY: * 321 * 12/19/1994 BR : Created. * 322 *=========================================================================*/ 323 int IPXAddressClass::operator == (IPXAddressClass & addr) 324 { 325 //------------------------------------------------------------------------ 326 // If either Network Number is all 0's (which can happen if the system is 327 // not running NETX), compare only the Node Addresses. 328 //------------------------------------------------------------------------ 329 if ( (NetworkNumber[0]==0 && 330 NetworkNumber[1]==0 && 331 NetworkNumber[2]==0 && 332 NetworkNumber[3]==0) || 333 (addr.NetworkNumber[0]==0 && 334 addr.NetworkNumber[1]==0 && 335 addr.NetworkNumber[2]==0 && 336 addr.NetworkNumber[3]==0) ) { 337 338 if (memcmp(NodeAddress,addr.NodeAddress,6)==0) { 339 return(1); 340 } 341 else { 342 return(0); 343 } 344 345 } 346 //------------------------------------------------------------------------ 347 // Otherwise, compare both the Network Numbers and Node Addresses 348 //------------------------------------------------------------------------ 349 else { 350 if (memcmp(NodeAddress,addr.NodeAddress,6)==0 && 351 memcmp(NetworkNumber,addr.NetworkNumber,4)==0) { 352 return(1); 353 } 354 else { 355 return(0); 356 } 357 } 358 359 } /* end of operator== */ 360 361 362 /*************************************************************************** 363 * IPXAddressClass::operator!= -- overloaded comparison operator * 364 * * 365 * Since, if NETX isn't running, the network number on a received packet * 366 * can be bogus (all 0's), only the node address is used for comparison * 367 * purposes here. * 368 * * 369 * INPUT: * 370 * addr address to compare to * 371 * * 372 * OUTPUT: * 373 * 0 = equal, 1 = not equal * 374 * * 375 * WARNINGS: * 376 * none. * 377 * * 378 * HISTORY: * 379 * 12/19/1994 BR : Created. * 380 *=========================================================================*/ 381 int IPXAddressClass::operator != (IPXAddressClass & addr) 382 { 383 //------------------------------------------------------------------------ 384 // If either Network Number is all 0's (which can happen if the system is 385 // not running NETX), compare only the Node Addresses. 386 //------------------------------------------------------------------------ 387 if ( (NetworkNumber[0]==0 && 388 NetworkNumber[1]==0 && 389 NetworkNumber[2]==0 && 390 NetworkNumber[3]==0) || 391 (addr.NetworkNumber[0]==0 && 392 addr.NetworkNumber[1]==0 && 393 addr.NetworkNumber[2]==0 && 394 addr.NetworkNumber[3]==0) ) { 395 396 if (memcmp(NodeAddress,addr.NodeAddress,6)==0) { 397 return(0); 398 } 399 else { 400 return(1); 401 } 402 } 403 //------------------------------------------------------------------------ 404 // Otherwise, compare both the Network Numbers and Node Addresses 405 //------------------------------------------------------------------------ 406 else { 407 if (memcmp(NodeAddress,addr.NodeAddress,6)==0 && 408 memcmp(NetworkNumber,addr.NetworkNumber,4)==0) { 409 return(0); 410 } 411 else { 412 return(1); 413 } 414 } 415 416 } /* end of operator!= */ 417 418 419 /*************************************************************************** 420 * IPXAddressClass::operator > -- overloaded comparison operator * 421 * * 422 * INPUT: * 423 * addr address to compare to * 424 * * 425 * OUTPUT: * 426 * TRUE = greater, FALSE = not * 427 * * 428 * WARNINGS: * 429 * none. * 430 * * 431 * HISTORY: * 432 * 12/19/1994 BR : Created. * 433 *=========================================================================*/ 434 int IPXAddressClass::operator > (IPXAddressClass & addr) 435 { 436 return(memcmp(this, &addr, 10) > 0); 437 438 } /* end of operator> */ 439 440 441 /*************************************************************************** 442 * IPXAddressClass::operator < -- overloaded comparison operator * 443 * * 444 * INPUT: * 445 * addr address to compare to * 446 * * 447 * OUTPUT: * 448 * TRUE = less, FALSE = not * 449 * * 450 * WARNINGS: * 451 * none. * 452 * * 453 * HISTORY: * 454 * 12/19/1994 BR : Created. * 455 *=========================================================================*/ 456 int IPXAddressClass::operator < (IPXAddressClass & addr) 457 { 458 return(memcmp(this, &addr, 10) < 0); 459 460 } /* end of operator< */ 461 462 463 /*************************************************************************** 464 * IPXAddressClass::operator >= -- overloaded comparison operator * 465 * * 466 * INPUT: * 467 * addr address to compare to * 468 * * 469 * OUTPUT: * 470 * TRUE = greater or equal, FALSE = not * 471 * * 472 * WARNINGS: * 473 * none. * 474 * * 475 * HISTORY: * 476 * 12/19/1994 BR : Created. * 477 *=========================================================================*/ 478 int IPXAddressClass::operator >= (IPXAddressClass & addr) 479 { 480 return(memcmp(this, &addr, 10) >= 0); 481 482 } /* end of operator>= */ 483 484 485 /*************************************************************************** 486 * IPXAddressClass::operator <= -- overloaded comparison operator * 487 * * 488 * INPUT: * 489 * addr address to compare to * 490 * * 491 * OUTPUT: * 492 * TRUE = less or equal, FALSE = not * 493 * * 494 * WARNINGS: * 495 * none. * 496 * * 497 * HISTORY: * 498 * 12/19/1994 BR : Created. * 499 *=========================================================================*/ 500 int IPXAddressClass::operator <= (IPXAddressClass & addr) 501 { 502 return(memcmp(this, &addr, 10) <= 0); 503 504 } /* end of operator<= */ 505 506 /************************** end of ipxaddr.cpp *****************************/