Mercurial > hg > nnchat

comparison libnnchat.c @ 97:218efd2f0641

Find changesets by keywords (author, files, the commit message), revision number or hash, or revset expression.
Rename functions for clarity.
author Matti Hamalainen <ccr@tnsp.org>
date Tue, 17 Nov 2009 19:20:25 +0200
parents 69f9c46e4a94
children b096ae97fc7d
comparison
equal deleted inserted replaced
96:7c9538e71c89 97:218efd2f0641
26 static char buf[64]; 26 static char buf[64];
27 snprintf(buf, sizeof(buf), "Error #%d", err); 27 snprintf(buf, sizeof(buf), "Error #%d", err);
28 return buf; 28 return buf;
29 } 29 }
30 30
31 int getSocketErrno(void) 31 int nn_get_socket_errno(void)
32 { 32 {
33 return WSAGetLastError(); 33 return WSAGetLastError();
34 } 34 }
35 35
36 const char *getSocketErrStr(int err) 36 const char *nn_get_socket_errstr(int err)
37 { 37 {
38 static char buf[64]; 38 static char buf[64];
39 snprintf(buf, sizeof(buf), "Error #%d", err); 39 snprintf(buf, sizeof(buf), "Error #%d", err);
40 return buf; 40 return buf;
41 } 41 }
42 #else 42 #else
43 int getSocketErrno(void) 43 int nn_get_socket_errno(void)
44 { 44 {
45 return errno; 45 return errno;
46 } 46 }
47 47
48 const char *getSocketErrStr(int err) 48 const char *nn_get_socket_errstr(int err)
49 { 49 {
50 return strerror(err); 50 return strerror(err);
51 } 51 }
52 #endif 52 #endif
53 53
54 54
55 int openConnection(struct in_addr *addr, const int port) 55 int nn_open_connection(struct in_addr *addr, const int port)
56 { 56 {
57 struct sockaddr_in tmpAddr; 57 struct sockaddr_in tmpAddr;
58 int sock = -1; 58 int sock = -1;
59 59
60 tmpAddr.sin_family = AF_INET; 60 tmpAddr.sin_family = AF_INET;
78 78
79 return sock; 79 return sock;
80 } 80 }
81 81
82 82
83 void closeConnection(const int sock) 83 void nn_close_connection(const int sock)
84 { 84 {
85 if (sock >= 0) { 85 if (sock >= 0) {
86 #ifdef __WIN32 86 #ifdef __WIN32
87 closesocket(sock); 87 closesocket(sock);
88 #else 88 #else
90 #endif 90 #endif
91 } 91 }
92 } 92 }
93 93
94 94
95 BOOL initNetwork(void) 95 BOOL nn_network_init(void)
96 { 96 {
97 #ifdef __WIN32 97 #ifdef __WIN32
98 /* Initialize WinSock, if needed */ 98 /* Initialize WinSock, if needed */
99 WSADATA wsaData; 99 WSADATA wsaData;
100 int err = WSAStartup(0x0101, &wsaData); 100 int err = WSAStartup(0x0101, &wsaData);
105 #endif 105 #endif
106 return TRUE; 106 return TRUE;
107 } 107 }
108 108
109 109
110 void closeNetwork(void) 110 void nn_network_close(void)
111 { 111 {
112 #ifdef __WIN32 112 #ifdef __WIN32
113 WSACleanup(); 113 WSACleanup();
114 #endif 114 #endif
115 } 115 }
116 116
117 117
118 BOOL sendToSocket(const int sock, char *buf, const size_t bufLen) 118 BOOL nn_send_to_socket(const int sock, char *buf, const size_t bufLen)
119 { 119 {
120 size_t bufLeft = bufLen; 120 size_t bufLeft = bufLen;
121 char *bufPtr = buf; 121 char *bufPtr = buf;
122 122
123 while (bufLeft > 0) { 123 while (bufLeft > 0) {
162 (*pos) += tmpLen; 162 (*pos) += tmpLen;
163 return TRUE; 163 return TRUE;
164 } 164 }
165 165
166 166
167 char *encodeStr1(const char *str) 167 char *nn_encode_str1(const char *str)
168 { 168 {
169 const char *s = str; 169 const char *s = str;
170 char *result; 170 char *result;
171 size_t resSize, resPos = 0; 171 size_t resSize, resPos = 0;
172 172
216 216
217 return i << shift; 217 return i << shift;
218 } 218 }
219 219
220 220
221 char *decodeStr1(const char *str) 221 char *nn_decode_str1(const char *str)
222 { 222 {
223 const char *s = str; 223 const char *s = str;
224 char *result; 224 char *result;
225 size_t resSize, resPos = 0; 225 size_t resSize, resPos = 0;
226 int c; 226 int c;
278 278
279 return result; 279 return result;
280 } 280 }
281 281
282 282
283 char *stripXMLTags(const char *str) 283 char *nn_strip_tags(const char *str)
284 { 284 {
285 const char *s = str; 285 const char *s = str;
286 char *result; 286 char *result;
287 size_t resSize, resPos = 0; 287 size_t resSize, resPos = 0;
288 288
303 303
304 return result; 304 return result;
305 } 305 }
306 306
307 307
308 char *encodeStr2(const char *str) 308 char *nn_encode_str2(const char *str)
309 { 309 {
310 const char *s = str; 310 const char *s = str;
311 char *result; 311 char *result;
312 size_t resSize, resPos = 0; 312 size_t resSize, resPos = 0;
313 313
334 334
335 return result; 335 return result;
336 } 336 }
337 337
338 338
339 char *decodeStr2(const char *str) 339 char *nn_decode_str2(const char *str)
340 { 340 {
341 const char *s = str; 341 const char *s = str;
342 char *result; 342 char *result;
343 size_t resSize, resPos = 0; 343 size_t resSize, resPos = 0;
344 344
370 370
371 return result; 371 return result;
372 } 372 }
373 373
374 374
375 char *doubleDecodeStr(const char *str) 375 char *nn_dbldecode_str(const char *str)
376 { 376 {
377 char *res, *tmp; 377 char *res, *tmp;
378 378
379 if ((tmp = decodeStr1(str)) == NULL) 379 if ((tmp = nn_decode_str1(str)) == NULL)
380 return NULL; 380 return NULL;
381 381
382 res = decodeStr2(tmp); 382 res = nn_decode_str2(tmp);
383 th_free(tmp); 383 th_free(tmp);
384 384
385 return res; 385 return res;
386 } 386 }
387 387
388 388
389 char *doubleEncodeStr(const char *str) 389 char *nn_dblencode_str(const char *str)
390 { 390 {
391 char *res, *tmp; 391 char *res, *tmp;
392 392
393 if ((tmp = encodeStr2(str)) == NULL) 393 if ((tmp = nn_encode_str2(str)) == NULL)
394 return NULL; 394 return NULL;
395 395
396 res = encodeStr1(tmp); 396 res = nn_encode_str1(tmp);
397 th_free(tmp); 397 th_free(tmp);
398 398
399 return res; 399 return res;
400 } 400 }
401 401
402 402
403 BOOL sendUserMsg(const int sock, const char *user, const char *fmt, ...) 403 BOOL nn_send_msg(const int sock, const char *user, const char *fmt, ...)
404 { 404 {
405 char tmpBuf[SET_BUFSIZE], tmpBuf2[SET_BUFSIZE + 256]; 405 char tmpBuf[SET_BUFSIZE], tmpBuf2[SET_BUFSIZE + 256];
406 int n; 406 int n;
407 va_list ap; 407 va_list ap;
408 408
414 414
415 snprintf(tmpBuf2, sizeof(tmpBuf2), 415 snprintf(tmpBuf2, sizeof(tmpBuf2),
416 "<USER>%s</USER><MESSAGE>%s</MESSAGE>", 416 "<USER>%s</USER><MESSAGE>%s</MESSAGE>",
417 user, tmpBuf); 417 user, tmpBuf);
418 418
419 return sendToSocket(sock, tmpBuf2, strlen(tmpBuf2) + 1); 419 return nn_send_to_socket(sock, tmpBuf2, strlen(tmpBuf2) + 1);
420 } 420 }
421 421
422 422
423 nn_ringbuf_t * newRingBuf(const size_t size) 423 nn_ringbuf_t * nn_ringbuf_new(const size_t size)
424 { 424 {
425 nn_ringbuf_t *res = th_calloc(1, sizeof(nn_ringbuf_t)); 425 nn_ringbuf_t *res = th_calloc(1, sizeof(nn_ringbuf_t));
426 426
427 res->data = (char **) th_malloc(size * sizeof(char *)); 427 res->data = (char **) th_malloc(size * sizeof(char *));
428 res->size = size; 428 res->size = size;
430 430
431 return res; 431 return res;
432 } 432 }
433 433
434 434
435 void freeRingBuf(nn_ringbuf_t *buf) 435 void nn_ringbuf_free(nn_ringbuf_t *buf)
436 { 436 {
437 size_t i; 437 size_t i;
438 438
439 for (i = 0; i < buf->n; i++) 439 for (i = 0; i < buf->n; i++)
440 th_free(buf->data[i]); 440 th_free(buf->data[i]);
442 th_free(buf->data); 442 th_free(buf->data);
443 th_free(buf); 443 th_free(buf);
444 } 444 }
445 445
446 446
447 void addRingBuf(nn_ringbuf_t *buf, const char *str) 447 void nn_ringbuf_add(nn_ringbuf_t *buf, const char *str)
448 { 448 {
449 if (buf->n < buf->size) { 449 if (buf->n < buf->size) {
450 buf->data[buf->n] = th_strdup(str); 450 buf->data[buf->n] = th_strdup(str);
451 buf->n++; 451 buf->n++;
452 } else { 452 } else {
455 buf->data[buf->size - 1] = th_strdup(str); 455 buf->data[buf->size - 1] = th_strdup(str);
456 } 456 }
457 } 457 }
458 458
459 459
460 int writeBuf(nn_editbuf_t *buf, ssize_t pos, int ch) 460 int nn_editbuf_write(nn_editbuf_t *buf, ssize_t pos, int ch)
461 { 461 {
462 /* Check arguments */ 462 /* Check arguments */
463 if (buf->len+1 >= buf->size) return -3; 463 if (buf->len+1 >= buf->size) return -3;
464 464
465 if (pos < 0) 465 if (pos < 0)
471 } 471 }
472 return 0; 472 return 0;
473 } 473 }
474 474
475 475
476 int insertBuf(nn_editbuf_t *buf, ssize_t pos, int ch) 476 int nn_editbuf_insert(nn_editbuf_t *buf, ssize_t pos, int ch)
477 { 477 {
478 /* Check arguments */ 478 /* Check arguments */
479 if (buf->len+1 >= buf->size) return -3; 479 if (buf->len+1 >= buf->size) return -3;
480 480
481 if (pos < 0) 481 if (pos < 0)
489 buf->len++; 489 buf->len++;
490 return 0; 490 return 0;
491 } 491 }
492 492
493 493
494 int deleteBuf(nn_editbuf_t *buf, ssize_t pos) 494 int nn_editbuf_delete(nn_editbuf_t *buf, ssize_t pos)
495 { 495 {
496 /* Check arguments */ 496 /* Check arguments */
497 if (pos < 0) 497 if (pos < 0)
498 return -1; 498 return -1;
499 else if (pos < buf->len) { 499 else if (pos < buf->len) {
503 } else 503 } else
504 return -2; 504 return -2;
505 } 505 }
506 506
507 507
508 void clearBuf(nn_editbuf_t *buf) 508 void nn_editbuf_clear(nn_editbuf_t *buf)
509 { 509 {
510 buf->len = 0; 510 buf->len = 0;
511 buf->pos = 0; 511 buf->pos = 0;
512 } 512 }
513 513
514 514
515 nn_editbuf_t * newBuf(ssize_t n) 515 nn_editbuf_t * nn_editbuf_new(ssize_t n)
516 { 516 {
517 nn_editbuf_t *res = th_calloc(1, sizeof(nn_editbuf_t)); 517 nn_editbuf_t *res = th_calloc(1, sizeof(nn_editbuf_t));
518 518
519 res->data = (char *) th_malloc(n); 519 res->data = (char *) th_malloc(n);
520 res->size = n; 520 res->size = n;
521 521
522 return res; 522 return res;
523 } 523 }
524 524
525 525
526 void freeBuf(nn_editbuf_t *buf) 526 void nn_editbuf_free(nn_editbuf_t *buf)
527 { 527 {
528 if (buf) { 528 if (buf) {
529 th_free(buf->data); 529 th_free(buf->data);
530 th_free(buf); 530 th_free(buf);
531 } 531 }
532 } 532 }
533 533
534 534
535 nn_editbuf_t * copyBuf(nn_editbuf_t *src) 535 nn_editbuf_t * nn_editbuf_copy(nn_editbuf_t *src)
536 { 536 {
537 nn_editbuf_t *res; 537 nn_editbuf_t *res;
538 538
539 assert(src != NULL); 539 assert(src != NULL);
540 540
541 if (src == NULL) return NULL; 541 if (src == NULL) return NULL;
542 542
543 if ((res = newBuf(src->size)) == NULL) 543 if ((res = nn_editbuf_new(src->size)) == NULL)
544 return NULL; 544 return NULL;
545 545
546 memcpy(res->data, src->data, src->size); 546 memcpy(res->data, src->data, src->size);
547 res->pos = res->len = src->len; 547 res->pos = res->len = src->len;
548 548
549 return res; 549 return res;
550 } 550 }
551 551
552 552
553 void setBufPos(nn_editbuf_t *buf, ssize_t pos) 553 void nn_editbuf_setpos(nn_editbuf_t *buf, ssize_t pos)
554 { 554 {
555 /* Check arguments */ 555 /* Check arguments */
556 if (pos < 0) 556 if (pos < 0)
557 buf->pos = 0; 557 buf->pos = 0;
558 else if (pos >= buf->len) 558 else if (pos >= buf->len)
627 /* No, we'll add it */ 627 /* No, we'll add it */
628 if ((user = th_calloc(1, sizeof(nn_user_t))) == NULL) 628 if ((user = th_calloc(1, sizeof(nn_user_t))) == NULL)
629 return -3; 629 return -3;
630 630
631 user->encname = th_strdup(encname); 631 user->encname = th_strdup(encname);
632 user->name = doubleDecodeStr(encname); 632 user->name = nn_dbldecode_str(encname);
633 if (user->encname == NULL || user->name == NULL) 633 if (user->encname == NULL || user->name == NULL)
634 return -4; 634 return -4;
635 635
636 hash = hashUserName(encname); 636 hash = hashUserName(encname);
637 insertUser(&((*list)->buckets[hash]), user); 637 insertUser(&((*list)->buckets[hash]), user);