cocoa-mule/EC.mm

   1
   2 #import "EC.h"
   3
   4 #import <CommonCrypto/CommonDigest.h>
   5
   6 @implementation ECTag
   7
   8 @synthesize tagName = m_name;
   9 @synthesize tagType = m_type;
  10 @synthesize subtags = m_subtags;
  11
  12 + (id)tagFromBuffer:(uint8_t **) buffer withLenght:(int) length {
  13         ECTag *tag = nil; //[[ECTag alloc] init];
  14
  15         if ( length < 4 ) {
  16                 NSLog(@"[EC] buffer for tag is too short");
  17                 return nil;
  18         }
  19
  20         uint16_t name16 = *(uint16_t *)(*buffer);
  21         name16 = ntohs(name16);
  22         bool have_subtags = (name16 & 1) != 0;
  23         name16 >>= 1;
  24         ECTagNames tag_name = (ECTagNames)(name16);
  25         *buffer += sizeof(name16);
  26
  27         uint8_t type8 = *(*buffer);
  28         ECTagTypes tag_type = (ECTagTypes)type8;
  29         *buffer += sizeof(type8);
  30
  31         uint32_t size32 = *(uint32_t *)(*buffer);
  32         size32 = ntohl(size32);
  33         *buffer += sizeof(uint32_t);
  34
  35         NSMutableArray *subtags = have_subtags ? [ECTag readSubtags:buffer withLenght:(length-3)] : nil;
  36
  37         switch (tag_type) {
  38                 case EC_TAGTYPE_UINT8:
  39                         tag = [ECTagInt8 tagFromBuffer:buffer];
  40                         break;
  41                 case EC_TAGTYPE_UINT16:
  42                         tag = [ECTagInt16 tagFromBuffer:buffer];
  43                         break;
  44                 case EC_TAGTYPE_UINT32:
  45                         tag = [ECTagInt32 tagFromBuffer:buffer];
  46                         break;
  47                 case EC_TAGTYPE_UINT64:
  48                         tag = [ECTagInt64 tagFromBuffer:buffer];
  49                         break;
  50                 case EC_TAGTYPE_HASH16:
  51                         tag = [ECTagMD5 tagFromBuffer:buffer];
  52                         break;
  53                 case EC_TAGTYPE_STRING:
  54                         tag = [ECTagString tagFromBuffer:buffer];
  55                         break;
  56                 default: ;
  57                         break;
  58         }
  59         if ( tag != nil ) {
  60                 tag->m_name = tag_name;
  61                 tag->m_subtags = subtags;
  62         }
  63         return tag;
  64 }
  65
  66 + (NSMutableArray *)readSubtags:(uint8_t **) buffer withLenght:(int) length {
  67
  68         uint16_t count16 = *(uint16_t *)(*buffer);
  69         count16 = ntohs(count16);
  70         *buffer += sizeof(count16);
  71         NSMutableArray *array = [[NSMutableArray alloc] init];
  72         [array retain];
  73         for(int i = 0; i < count16; i++) {
  74                 id tag = [ECTag tagFromBuffer:buffer withLenght:length];
  75                 if ( tag != nil ) {
  76                         [array addObject:tag];
  77                 }
  78         }
  79
  80         return array;
  81 }
  82
  83 - (void)writeToSocket:(NSOutputStream *) socket {
  84         uint16_t name16 = (uint16_t)m_name;
  85         name16 <<= 1;
  86         uint8_t type8 = (uint8_t)m_type;
  87         if ( [m_subtags count] ) {
  88                 name16 |= 1;
  89         }
  90         name16 = htons(name16);
  91         [socket write:(uint8_t *)&name16 maxLength:sizeof(name16)];
  92         [socket write:&type8 maxLength:sizeof(type8)];
  93         uint32_t size32 = [self getSize];
  94         size32 = htonl(size32);
  95         [socket write:(uint8_t *)&size32 maxLength:sizeof(size32)];
  96 }
  97
  98 - (void)writeSubtagsToSocket:(NSOutputStream *) socket {
  99         uint16_t count16 = [m_subtags count];
 100         count16 = htons(count16);
 101         [socket write:(uint8_t *)&count16 maxLength:sizeof(count16)];
 102         for (ECTag *t in m_subtags) {
 103                 [t writeToSocket:socket];
 104         }
 105 }
 106
 107 - (int)getSize {
 108         int total_size = m_size;
 109         for (ECTag *t in m_subtags) {
 110                 total_size += [t getSize];
 111                 // name + type + size
 112                 total_size += (2 + 1 + 4);
 113                 if ([t->m_subtags count]) {
 114                         total_size += 2;
 115                 }
 116         }
 117         return total_size;
 118 }
 119
 120 - (id)tagByName:(ECTagNames) tagname {
 121         ECTag *mytag = nil;
 122         for (ECTag *t in m_subtags) {
 123                 if (t.tagName == tagname) {
 124                         mytag = t;
 125                         break;
 126                 }
 127         }
 128         return mytag;
 129 }
 130
 131 - (void)initSubtags {
 132         m_subtags = [NSMutableArray array];
 133         [m_subtags retain];
 134 }
 135
 136 - (void) dealloc {
 137         [m_subtags release];
 138         [super dealloc];
 139 }
 140
 141 - (uint64_t)tagInt64ByName: (ECTagNames) tagname {
 142         ECTag *st = [self tagByName: tagname];
 143         if (st == nil) {
 144                 return 0;
 145         }
 146         uint64_t value = 0;
 147         switch ([st getSize]) {
 148                 case 1: {
 149                         ECTagInt8 *t = (ECTagInt8 *)st;
 150                         value = t.uint8Value;
 151                         break;
 152                         }
 153                 case 2: {
 154                         ECTagInt16 *t = (ECTagInt16 *)st;
 155                         value = t.uint16Value;
 156                         break;
 157                         }
 158                 case 4: {
 159                         ECTagInt32 *t = (ECTagInt32 *)st;
 160                         value = t.uint32Value;
 161                         break;
 162                         }
 163                 case 8: {
 164                         ECTagInt64 *t = (ECTagInt64 *)st;
 165                         value = t.uint64Value;
 166                         break;
 167                         }
 168         }
 169         return value;
 170 }
 171
 172 - (int)tagCount {
 173         return [m_subtags count];
 174 }
 175
 176 @end
 177
 178 @implementation ECTagInt8
 179
 180 @synthesize uint8Value = m_val;
 181
 182 + (id)tagFromInt8:(uint8_t) value withName:(ECTagNames) name {
 183         ECTagInt8 *tag = [[ECTagInt8 alloc] init];
 184         tag->m_val = value;
 185         tag->m_size = 1;
 186         tag->m_type = EC_TAGTYPE_UINT8;
 187         tag->m_name = name;
 188
 189         return tag;
 190 }
 191
 192 + (id)tagFromBuffer:(uint8_t **) buffer {
 193         ECTagInt8 *tag = [[ECTagInt8 alloc] init];
 194         tag->m_val = **buffer;
 195         tag->m_size = 1;
 196         tag->m_type = EC_TAGTYPE_UINT8;
 197
 198         *buffer += 1;
 199
 200         return tag;
 201 }
 202
 203 - (void)writeToSocket:(NSOutputStream *) socket {
 204         [super writeToSocket:socket];
 205
 206         [socket write:&m_val maxLength:sizeof(m_val)];
 207 }
 208
 209 @end
 210
 211 @implementation ECTagInt16
 212
 213 @synthesize uint16Value = m_val;
 214
 215 + (id)tagFromInt16:(uint16_t) value withName:(ECTagNames) name {
 216         ECTagInt16 *tag = [[ECTagInt16 alloc] init];
 217         tag->m_val = value;
 218         tag->m_size = 2;
 219         tag->m_type = EC_TAGTYPE_UINT16;
 220         tag->m_name = name;
 221
 222         return tag;
 223 }
 224
 225 + (id)tagFromBuffer:(uint8_t **) buffer {
 226         ECTagInt16 *tag = [[ECTagInt16 alloc] init];
 227
 228         tag->m_val = ntohs(*((uint16_t *)(*buffer)));
 229         tag->m_size = 2;
 230         tag->m_type = EC_TAGTYPE_UINT16;
 231
 232         *buffer += 2;
 233
 234         return tag;
 235 }
 236
 237
 238 @end
 239
 240 @implementation ECTagInt32
 241
 242 @synthesize uint32Value = m_val;
 243
 244 + (id)tagFromInt32:(uint32_t) value withName:(ECTagNames) name {
 245         ECTagInt32 *tag = [[ECTagInt32 alloc] init];
 246         tag->m_val = value;
 247         tag->m_size = 4;
 248         tag->m_type = EC_TAGTYPE_UINT32;
 249         tag->m_name = name;
 250
 251         return tag;
 252 }
 253
 254 + (id)tagFromBuffer:(uint8_t **) buffer {
 255         ECTagInt32 *tag = [[ECTagInt32 alloc] init];
 256
 257         tag->m_val = ntohl(*((uint32_t *)(*buffer)));
 258         tag->m_size = 4;
 259         tag->m_type = EC_TAGTYPE_UINT32;
 260
 261         *buffer += 4;
 262
 263         return tag;
 264 }
 265
 266
 267 @end
 268
 269 @implementation ECTagInt64
 270
 271 @synthesize uint64Value = m_val;
 272
 273 + (id)tagFromInt64:(uint64_t) value withName:(ECTagNames) name {
 274         ECTagInt64 *tag = [[ECTagInt64 alloc] init];
 275         tag->m_val = value;
 276         tag->m_size = 8;
 277         tag->m_type = EC_TAGTYPE_UINT64;
 278         tag->m_name = name;
 279
 280         return tag;
 281 }
 282
 283
 284 + (id)tagFromBuffer:(uint8_t **) buffer {
 285         ECTagInt64 *tag = [[ECTagInt64 alloc] init];
 286         uint64_t lo, hi;
 287         uint32 val32 = *((uint32_t *)(*buffer));
 288         lo = ntohl(val32);
 289         *buffer += 4;
 290
 291         val32 = *((uint32_t *)(*buffer));
 292         hi = ntohl(val32);
 293         *buffer += 4;
 294
 295         tag->m_val = (hi << 32) | lo;
 296         tag->m_size = 8;
 297         tag->m_type = EC_TAGTYPE_UINT64;
 298
 299         return tag;
 300 }
 301
 302
 303 - (void)writeToSocket:(NSOutputStream *) socket {
 304         [super writeToSocket:socket];
 305
 306         uint32_t val32 = m_val >> 32;
 307         val32 = htonl(val32);
 308         [socket write:(uint8_t *)&val32 maxLength:sizeof(val32)];
 309
 310         val32 = m_val & 0xffffffff;
 311         val32 = htonl(val32);
 312         [socket write:(uint8_t *)&val32 maxLength:sizeof(val32)];
 313 }
 314
 315 @end
 316
 317
 318 @implementation ECTagData
 319
 320 - (void)writeToSocket:(NSOutputStream *) socket {
 321         [super writeToSocket:socket];
 322
 323         [socket write:(const uint8_t *)[m_data bytes] maxLength:m_size];
 324 }
 325
 326 - (void) dealloc {
 327         [m_data release];
 328         [super dealloc];
 329 }
 330
 331 + (id)tagFromBuffer:(uint8_t **) buffer withLenght:(int) length {
 332         ECTagData *tag = [[ECTagData alloc] init];
 333
 334         tag->m_data = [NSData dataWithBytes: *buffer length: length];
 335         [tag->m_data retain];
 336
 337         return tag;
 338 }
 339
 340
 341 @end
 342
 343 @implementation ECTagMD5
 344
 345 + (id)tagFromString:(NSString *) string withName:(ECTagNames) name {
 346         ECTagMD5 *tag = [[ECTagMD5 alloc] init];
 347
 348         CC_MD5_CTX ctx;
 349         unsigned char md5data[16];
 350         CC_MD5_Init(&ctx);
 351         CC_MD5_Update(&ctx, [string UTF8String], [string length]);
 352         CC_MD5_Final(md5data, &ctx);
 353
 354         tag->m_data = [NSData dataWithBytes: md5data length: sizeof(md5data)];
 355         [tag->m_data retain];
 356         tag->m_size = 16;
 357         tag->m_type = EC_TAGTYPE_HASH16;
 358         tag->m_name = name;
 359
 360         return tag;
 361 }
 362
 363 + (id)tagFromBuffer:(uint8_t **) buffer {
 364         ECTagMD5 *tag = [[ECTagMD5 alloc] init];
 365
 366         tag->m_data = 0;
 367         tag->m_val.lo = *((uint64_t *)(*buffer));
 368         (*buffer) += 8;
 369         tag->m_val.hi = *((uint64_t *)(*buffer));
 370         (*buffer) += 8;
 371
 372         return tag;
 373 }
 374
 375 - (MD5Data)getMD5Data {
 376         if ( m_data ) {
 377                 uint8_t *data_ptr = (uint8_t *)[m_data bytes];
 378
 379                 uint64_t hi = *(uint64_t *)data_ptr;
 380                 data_ptr += 8;
 381                 uint64_t lo = *(uint64_t *)data_ptr;
 382                 MD5Data md5 = {hi, lo};
 383                 return md5;
 384         } else {
 385                 return m_val;
 386         }
 387 }
 388 - (NSString *)stringKey {
 389         NSString *s = [NSString stringWithFormat:@"%qx%qx", m_val.hi, m_val.lo];
 390         return s;
 391 }
 392
 393 @end
 394
 395 @implementation ECTagString
 396
 397 @synthesize stringValue = m_val;
 398
 399 + tagFromString:(NSString *) string withName:(ECTagNames) name {
 400         ECTagString *tag = [[ECTagString alloc] init];
 401
 402         const char *rawstring = [string UTF8String];
 403         tag->m_size = strlen(rawstring) + 1;
 404         tag->m_data = [NSData dataWithBytes: rawstring length: tag->m_size];
 405         [tag->m_data retain];
 406         tag->m_type = EC_TAGTYPE_STRING;
 407         tag->m_name = name;
 408
 409         return tag;
 410 }
 411
 412 + (id)tagFromBuffer:(uint8_t **) buffer {
 413         ECTagString *tag = [[ECTagString alloc] init];
 414
 415         tag->m_val = [NSString stringWithCString:(char *)(*buffer) encoding:NSUTF8StringEncoding];
 416         *buffer += [tag->m_val length] + 1;
 417
 418         return tag;
 419 }
 420
 421 @end
 422
 423 @implementation ECPacket
 424
 425 @synthesize opcode = m_opcode;
 426
 427 + (id)packetWithOpcode:(ec_opcode_t) opcode {
 428         ECPacket *p = [[ECPacket alloc] init];
 429
 430         [p initWithOpcode:opcode];
 431
 432         return p;
 433 }
 434
 435
 436 - (void)initWithOpcode:(ec_opcode_t) opcode {
 437         m_opcode = opcode;
 438         m_flags = 0x20;
 439
 440         // allow notification push to my client
 441         m_flags |= EC_FLAG_NOTIFY | EC_FLAG_ACCEPTS;
 442
 443         [self initSubtags];
 444 }
 445
 446 + (id)packetFromBuffer:(uint8_t *) buffer withLength:(int)length {
 447         if ( length < 11 ) {
 448                 return nil;
 449         }
 450         ECPacket *p = [[ECPacket alloc] init];
 451         uint8_t *data = buffer;
 452
 453         p->m_flags = ntohl(*((uint32_t *)data));
 454         data += 4;
 455         uint32_t packet_size = ntohl(*((uint32_t *)data));
 456         data += 4;
 457         if ( packet_size > 1024*1024 ) {
 458                 return nil;
 459         }
 460         p->m_opcode = (ec_opcode_t)(*data);
 461         data++;
 462
 463         uint16_t tag_count = ntohs(*((uint16_t *)data));
 464         data += 2;
 465         if ( tag_count ) {
 466                 p->m_subtags = [[NSMutableArray alloc] init];
 467                 [p->m_subtags retain];
 468                 uint8_t *start_ptr = data;
 469                 for(int i = 0; i < tag_count; i++) {
 470                         ECTag *tag = [ECTag tagFromBuffer:&data withLenght:(length - (data - start_ptr))];
 471                         // some tags are not supported yet
 472                         if ( tag != nil ) {
 473                                 [p->m_subtags addObject:tag];
 474                         }
 475                 }
 476         }
 477
 478         return p;
 479 }
 480
 481 - (void)writeToSocket:(NSOutputStream *) socket {
 482         // 1 (command) + 2 (tag count)
 483         int packet_size = [self getSize] + 1 + 2;
 484
 485 // No need for zlib on client side
 486 //      if ( packet_size > MaxUncompressedPacket ) {
 487 //              m_flags |= (Int32)ECFlags.EC_FLAG_ZLIB;
 488 //      }
 489         uint32_t val32 = htonl(m_flags);
 490         [socket write:(uint8_t *)&val32 maxLength:sizeof(val32)];
 491         if ( m_flags & EC_FLAG_ACCEPTS ) {
 492                 [socket write:(uint8_t *)&val32 maxLength:sizeof(val32)];
 493         }
 494         val32 = htonl(packet_size);
 495         [socket write:(uint8_t *)&val32 maxLength:sizeof(val32)];
 496         [socket write:(uint8_t *)&m_opcode maxLength:sizeof(m_opcode)];
 497
 498         if ( [m_subtags count] ) {
 499                 [self writeSubtagsToSocket:socket];
 500         } else {
 501                 uint16_t val16 = 0;
 502                 [socket write:(uint8_t *)&val16 maxLength:sizeof(val16)];
 503         }
 504 }
 505
 506 @end
 507
 508 @implementation ECLoginPacket
 509
 510 + (id)loginPacket:(NSString *) password withVersion:(NSString *) version {
 511         ECLoginPacket *p = [[ECLoginPacket alloc] init];
 512
 513         [p initWithOpcode:EC_OP_AUTH_REQ];
 514
 515         ECTagMD5 *passtag = [ECTagMD5 tagFromString: password withName:EC_TAG_PASSWD_HASH];
 516         [p->m_subtags addObject:passtag];
 517
 518         ECTagString *version_tag = [ECTagString tagFromString:version withName:EC_TAG_CLIENT_VERSION];
 519         [p->m_subtags addObject:version_tag];
 520
 521         ECTagString *client_name_tag = [ECTagString tagFromString:@"cocoa-frontend" withName:EC_TAG_CLIENT_NAME];
 522         [p->m_subtags addObject:client_name_tag];
 523
 524         ECTagInt64 *proto_version_tag = [ECTagInt64 tagFromInt64:EC_CURRENT_PROTOCOL_VERSION withName:EC_TAG_PROTOCOL_VERSION];
 525         [p->m_subtags addObject:proto_version_tag];
 526
 527         return p;
 528 }
 529
 530
 531 @end
 532
 533
 534 @implementation ECRemoteConnection
 535
 536 @synthesize error = m_error;
 537
 538 + (id)remoteConnection {
 539         ECRemoteConnection *p = [[ECRemoteConnection alloc] init];
 540
 541         //
 542         // rx buffer can be resized as needed
 543         //
 544         p->m_rxbuf = [NSMutableData dataWithLength:1024];
 545         [p->m_rxbuf retain];
 546
 547         //
 548         // client only transmit commands, which are
 549         // quite small in size. "big enough" buffer will do the trick
 550         //
 551 //      p->m_txbuf = [NSMutableData dataWithLength:1024];
 552 //      [p->m_txbuf retain];
 553         p->m_txbuf = nil;
 554
 555         return p;
 556 }
 557
 558 - (void) dealloc {
 559         [m_rxbuf release];
 560         [m_txbuf release];
 561
 562         [m_istream release];
 563         [m_ostream release];
 564
 565         [super dealloc];
 566 }
 567
 568
 569 - (void)connectToAddress:(NSString *) hostname withPort:(int)trgport {
 570         m_error = false;
 571
 572 //      NSHost *host = [NSHost hostWithName:hostname];
 573         NSHost *host = [NSHost hostWithAddress:hostname];
 574
 575         [NSStream getStreamsToHost:host port:trgport inputStream:&m_istream outputStream:&m_ostream];
 576
 577         [m_istream retain];
 578         [m_ostream retain];
 579
 580         [m_istream setDelegate:self];
 581         [m_ostream setDelegate:self];
 582
 583         [m_istream scheduleInRunLoop:[NSRunLoop currentRunLoop]
 584             forMode:NSDefaultRunLoopMode];
 585
 586         [m_ostream scheduleInRunLoop:[NSRunLoop currentRunLoop]
 587             forMode:NSDefaultRunLoopMode];
 588
 589         [m_istream open];
 590         [m_ostream open];
 591
 592         m_remaining_size = 8;
 593         m_rx_size = 0;
 594 }
 595
 596 - (void)sendLogin:(NSString *) password {
 597         m_login_requested = true;
 598         m_login_ok = false;
 599         ECLoginPacket *p = [ECLoginPacket loginPacket:password withVersion:@"0.1"];
 600         [self sendPacket:p];
 601 }
 602
 603 - (void)sendPacket:(ECPacket *) packet {
 604         NSOutputStream *memstream = [NSOutputStream outputStreamToMemory];
 605         [memstream open];
 606
 607         [packet writeToSocket:memstream];
 608         id data = [memstream propertyForKey:NSStreamDataWrittenToMemoryStreamKey];
 609
 610         m_tx_size = [data length];
 611         NSLog(@"[EC] sending packet %d bytes\n", m_tx_size);
 612         m_tx_ptr = [m_ostream write:(const uint8_t *)[data bytes] maxLength:[data length]];
 613         NSLog(@"[EC] %d bytes sent\n", m_tx_ptr);
 614         if ( m_tx_ptr == m_tx_size ) {
 615                 m_txbuf = nil;
 616         } else {
 617                 m_txbuf = (NSData *)data;
 618                 [m_txbuf retain];
 619         }
 620         NSStreamStatus stream_status = [m_ostream streamStatus];
 621         switch ( stream_status ) {
 622                 case NSStreamStatusNotOpen:
 623                 case NSStreamStatusClosed:
 624                 case NSStreamStatusError:
 625                         NSLog(@"[EC] error in output stream\n");
 626                         m_error = true;
 627                         break;
 628                 default:;
 629         }
 630 //      NSLog(@"[EC] status in output stream=%d\n", stream_status);
 631
 632 }
 633
 634 - (void)stream:(NSStream *)stream handleEvent:(NSStreamEvent)eventCode {
 635     switch(eventCode) {
 636                 case NSStreamEventOpenCompleted:
 637                 {
 638                         NSLog(@"[EC] open complete\n");
 639                         break;
 640                 }
 641                 case NSStreamEventErrorOccurred:
 642                 {
 643                         NSError *e = [stream streamError];
 644                         NSString *description = [e localizedDescription];
 645                         NSLog(@"[EC] socket error [%s]\n", [description UTF8String]);
 646                         break;
 647                 }
 648         case NSStreamEventHasBytesAvailable:
 649         {
 650                         uint8_t *data_ptr = (uint8_t *)[m_rxbuf mutableBytes];
 651                         unsigned int len = [m_rxbuf length];
 652
 653             len = [(NSInputStream *)stream read:data_ptr + m_rx_size maxLength:len];
 654 #ifdef EC_RX_DEBUG
 655                         NSLog(@"[EC] receiving %d bytes, %d in total, %d remaining\n", len, m_rx_size, m_remaining_size);
 656 #endif
 657                         if ( len == 0 ) {
 658                                 //
 659                                 // Remote side must be closed connection
 660                                 //
 661                                 m_error = true;
 662                                 if ( [delegate respondsToSelector:@selector(handleError)] ) {
 663                                         [delegate handleError];
 664                                 }
 665                         }
 666                         int total_len = len;
 667                         int packet_offset = 0;
 668                         while ( total_len != 0 ) {
 669                                 len = ( m_remaining_size > total_len ) ? total_len : m_remaining_size;
 670                                 total_len -= len;
 671
 672                                 // are we still waiting for flags and size?
 673                                 if ( m_rx_size < 8 ) {
 674                                         if ( (m_rx_size + len) >= 8 ) {
 675                                                 // got flags and packet size - may proceed
 676                                                 //uint32_t flags = *(((uint32_t *)[m_rxbuf mutableBytes]) + 0);
 677                                                 uint32_t val32 = *((uint32_t *)(data_ptr + 4 + packet_offset));
 678
 679                                                 int delta = 8 - m_rx_size;
 680
 681                                                 m_remaining_size = ntohl(val32) - (len - delta);
 682 #ifdef EC_RX_DEBUG
 683                                                 NSLog(@"[EC] rx got flags+size, remaining count %d\n", m_remaining_size);
 684 #endif
 685                                         } else {
 686                                                 m_remaining_size -= len;
 687                                         }
 688                                 } else {
 689                                         m_remaining_size -= len;
 690                                 }
 691                                 m_rx_size += len;
 692                                 if ( m_remaining_size == 0 ) {
 693                                         //
 694                                         // full packet received, call handler
 695                                         //
 696                                         uint8_t *packet_start = data_ptr + packet_offset;
 697                                         int packet_length = [m_rxbuf length] - packet_offset;
 698                                         ECPacket *packet = [ECPacket packetFromBuffer:packet_start withLength:packet_length];
 699                                         packet_offset += m_rx_size;
 700
 701                                         if ( m_login_requested ) {
 702                                                 m_login_requested = false;
 703                                                 m_login_ok = packet.opcode == EC_OP_AUTH_OK;
 704                                                 NSLog(@"[EC] server reply to login request: %@\n", m_login_ok ? @"login OK" : @"login FAILED");
 705                                         } else {
 706 #ifdef EC_RX_DEBUG
 707                                                 NSLog(@"[EC] calling delegate\n");
 708 #endif
 709                                                 if ( [delegate respondsToSelector:@selector(handlePacket:)] ) {
 710                                                         [delegate handlePacket: packet];
 711                                                 }
 712                                         }
 713                                         m_remaining_size = 8;
 714                                         m_rx_size = 0;
 715                                 }
 716                         }
 717             break;
 718         }
 719
 720         case NSStreamEventHasSpaceAvailable:
 721                 {
 722                         if ( m_txbuf != nil ) {
 723                                 int remaining = [m_txbuf length] - m_tx_ptr;
 724                                 if ( remaining ) {
 725                                         const uint8_t *txdata = ((const uint8_t *)[m_txbuf bytes]) + m_tx_ptr;
 726                                         int txcount = [m_ostream write:txdata maxLength:remaining];
 727                                         m_tx_ptr += txcount;
 728                                 } else {
 729                                         [m_txbuf release];
 730                                         m_txbuf = nil;
 731                                 }
 732
 733                         }
 734                         break;
 735                 }
 736         }
 737 }
 738
 739 - (void)setDelegate:(id)val
 740 {
 741     delegate = val;
 742 }
 743
 744 - (id)delegate
 745 {
 746     return delegate;
 747 }
 748
 749
 750 @end