libgadu/common.c

   1 /* $Id: common.c,v 1.3 2004/07/31 10:47:20 konst Exp $ */
   2
   3 /*
   4  *  (C) Copyright 2001-2002 Wojtek Kaniewski <wojtekka@irc.pl>
   5  *                          Robert J. Wo¼ny <speedy@ziew.org>
   6  *
   7  *  This program is free software; you can redistribute it and/or modify
   8  *  it under the terms of the GNU Lesser General Public License Version
   9  *  2.1 as published by the Free Software Foundation.
  10  *
  11  *  This program is distributed in the hope that it will be useful,
  12  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
  13  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  14  *  GNU Lesser General Public License for more details.
  15  *
  16  *  You should have received a copy of the GNU Lesser General Public
  17  *  License along with this program; if not, write to the Free Software
  18  *  Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
  19  */
  20
  21 #include <sys/types.h>
  22 #include <sys/ioctl.h>
  23 #include <sys/socket.h>
  24 #include <netinet/in.h>
  25 #include <arpa/inet.h>
  26 #ifdef sun
  27 #  include <sys/filio.h>
  28 #endif
  29
  30 #include <errno.h>
  31 #include <fcntl.h>
  32 #include <netdb.h>
  33 #include <stdarg.h>
  34 #include <stdio.h>
  35 #include <stdlib.h>
  36 #include <string.h>
  37 #include <unistd.h>
  38
  39 #include "libgadu.h"
  40
  41 FILE *gg_debug_file = NULL;
  42
  43 #ifndef GG_DEBUG_DISABLE
  44
  45 /*
  46  * gg_debug() // funkcja wewnêtrzna
  47  *
  48  * wy¶wietla komunikat o danym poziomie, o ile u¿ytkownik sobie tego ¿yczy.
  49  *
  50  *  - level - poziom wiadomo¶ci
  51  *  - format... - tre¶æ wiadomo¶ci (kompatybilna z printf())
  52  */
  53 void gg_debug(int level, const char *format, ...)
  54 {
  55         va_list ap;
  56         int old_errno = errno;
  57
  58         if (gg_debug_handler) {
  59                 va_start(ap, format);
  60                 (*gg_debug_handler)(level, format, ap);
  61                 va_end(ap);
  62
  63                 goto cleanup;
  64         }
  65
  66         if ((gg_debug_level & level)) {
  67                 va_start(ap, format);
  68                 vfprintf((gg_debug_file) ? gg_debug_file : stderr, format, ap);
  69                 va_end(ap);
  70         }
  71
  72 cleanup:
  73         errno = old_errno;
  74 }
  75
  76 #endif
  77
  78 /*
  79  * gg_vsaprintf() // funkcja pomocnicza
  80  *
  81  * robi dok³adnie to samo, co vsprintf(), tyle ¿e alokuje sobie wcze¶niej
  82  * miejsce na dane. powinno dzia³aæ na tych maszynach, które maj± funkcjê
  83  * vsnprintf() zgodn± z C99, jak i na wcze¶niejszych.
  84  *
  85  *  - format - opis wy¶wietlanego tekstu jak dla printf()
  86  *  - ap - lista argumentów dla printf()
  87  *
  88  * zaalokowany bufor, który nale¿y pó¼niej zwolniæ, lub NULL
  89  * je¶li nie uda³o siê wykonaæ zadania.
  90  */
  91 char *gg_vsaprintf(const char *format, va_list ap)
  92 {
  93         int size = 0;
  94         const char *start;
  95         char *buf = NULL;
  96
  97 #ifdef __GG_LIBGADU_HAVE_VA_COPY
  98         va_list aq;
  99
 100         va_copy(aq, ap);
 101 #else
 102 #  ifdef __GG_LIBGADU_HAVE___VA_COPY
 103         va_list aq;
 104
 105         __va_copy(aq, ap);
 106 #  endif
 107 #endif
 108
 109         start = format;
 110
 111 #ifndef __GG_LIBGADU_HAVE_C99_VSNPRINTF
 112         {
 113                 int res;
 114                 char *tmp;
 115
 116                 size = 256;
 117                 do {
 118                         size *= 2;
 119                         if (!(tmp = realloc(buf, size))) {
 120                                 free(buf);
 121                                 return NULL;
 122                         }
 123                         buf = tmp;
 124                         res = vsnprintf(buf, size, format, ap);
 125                 } while (res == size - 1 || res == -1);
 126         }
 127 #else
 128         {
 129                 char tmp[2];
 130
 131                 /* libce Solarisa przy buforze NULL zawsze zwracaj± -1, wiêc
 132                  * musimy podaæ co¶ istniej±cego jako cel printf()owania. */
 133                 size = vsnprintf(tmp, sizeof(tmp), format, ap);
 134                 if (!(buf = malloc(size + 1)))
 135                         return NULL;
 136         }
 137 #endif
 138
 139         format = start;
 140
 141 #ifdef __GG_LIBGADU_HAVE_VA_COPY
 142         vsnprintf(buf, size + 1, format, aq);
 143         va_end(aq);
 144 #else
 145 #  ifdef __GG_LIBGADU_HAVE___VA_COPY
 146         vsnprintf(buf, size + 1, format, aq);
 147         va_end(aq);
 148 #  else
 149         vsnprintf(buf, size + 1, format, ap);
 150 #  endif
 151 #endif
 152
 153         return buf;
 154 }
 155
 156 /*
 157  * gg_saprintf() // funkcja pomocnicza
 158  *
 159  * robi dok³adnie to samo, co sprintf(), tyle ¿e alokuje sobie wcze¶niej
 160  * miejsce na dane. powinno dzia³aæ na tych maszynach, które maj± funkcjê
 161  * vsnprintf() zgodn± z C99, jak i na wcze¶niejszych.
 162  *
 163  *  - format... - tre¶æ taka sama jak w funkcji printf()
 164  *
 165  * zaalokowany bufor, który nale¿y pó¼niej zwolniæ, lub NULL
 166  * je¶li nie uda³o siê wykonaæ zadania.
 167  */
 168 char *gg_saprintf(const char *format, ...)
 169 {
 170         va_list ap;
 171         char *res;
 172
 173         va_start(ap, format);
 174         res = gg_vsaprintf(format, ap);
 175         va_end(ap);
 176
 177         return res;
 178 }
 179
 180 /*
 181  * gg_get_line() // funkcja pomocnicza
 182  *
 183  * podaje kolejn± liniê z bufora tekstowego. niszczy go bezpowrotnie, dziel±c
 184  * na kolejne stringi. zdarza siê, nie ma potrzeby pisania funkcji dubluj±cej
 185  * bufor ¿eby tylko mieæ nieruszone dane wej¶ciowe, skoro i tak nie bêd± nam
 186  * po¼niej potrzebne. obcina `\r\n'.
 187  *
 188  *  - ptr - wska¼nik do zmiennej, która przechowuje aktualn± pozycjê
 189  *    w przemiatanym buforze
 190  *
 191  * wska¼nik do kolejnej linii tekstu lub NULL, je¶li to ju¿ koniec bufora.
 192  */
 193 char *gg_get_line(char **ptr)
 194 {
 195         char *foo, *res;
 196
 197         if (!ptr || !*ptr || !strcmp(*ptr, ""))
 198                 return NULL;
 199
 200         res = *ptr;
 201
 202         if (!(foo = strchr(*ptr, '\n')))
 203                 *ptr += strlen(*ptr);
 204         else {
 205                 *ptr = foo + 1;
 206                 *foo = 0;
 207                 if (strlen(res) > 1 && res[strlen(res) - 1] == '\r')
 208                         res[strlen(res) - 1] = 0;
 209         }
 210
 211         return res;
 212 }
 213
 214 /*
 215  * gg_connect() // funkcja pomocnicza
 216  *
 217  * ³±czy siê z serwerem. pierwszy argument jest typu (void *), ¿eby nie
 218  * musieæ niczego inkludowaæ w libgadu.h i nie psuæ jaki¶ g³upich zale¿no¶ci
 219  * na dziwnych systemach.
 220  *
 221  *  - addr - adres serwera (struct in_addr *)
 222  *  - port - port serwera
 223  *  - async - asynchroniczne po³±czenie
 224  *
 225  * deskryptor gniazda lub -1 w przypadku b³êdu (kod b³êdu w zmiennej errno).
 226  */
 227 int gg_connect(void *addr, int port, int async)
 228 {
 229         int sock, one = 1;
 230         struct sockaddr_in sin;
 231         struct in_addr *a = addr;
 232
 233         gg_debug(GG_DEBUG_FUNCTION, "** gg_connect(%s, %d, %d);\n", inet_ntoa(*a), port, async);
 234
 235         if ((sock = socket(AF_INET, SOCK_STREAM, IPPROTO_TCP)) == -1) {
 236                 gg_debug(GG_DEBUG_MISC, "// gg_connect() socket() failed (errno=%d, %s)\n", errno, strerror(errno));
 237                 return -1;
 238         }
 239
 240 #ifdef ASSIGN_SOCKETS_TO_THREADS
 241         gg_win32_thread_socket(0, sock);
 242 #endif
 243
 244         if (async) {
 245 #ifdef FIONBIO
 246                 if (ioctl(sock, FIONBIO, &one) == -1) {
 247 #else
 248                 if (fcntl(sock, F_SETFL, O_NONBLOCK) == -1) {
 249 #endif
 250                         gg_debug(GG_DEBUG_MISC, "// gg_connect() ioctl() failed (errno=%d, %s)\n", errno, strerror(errno));
 251                         close(sock);
 252                         return -1;
 253                 }
 254         }
 255
 256         sin.sin_port = htons(port);
 257         sin.sin_family = AF_INET;
 258         sin.sin_addr.s_addr = a->s_addr;
 259
 260         if(cw_connect(sock, (struct sockaddr*) &sin, sizeof(sin), 0) == -1) {
 261                 if (errno && (!async || errno != EINPROGRESS)) {
 262                         gg_debug(GG_DEBUG_MISC, "// gg_connect() connect() failed (errno=%d, %s)\n", errno, strerror(errno));
 263                         close(sock);
 264                         return -1;
 265                 }
 266                 gg_debug(GG_DEBUG_MISC, "// gg_connect() connect() in progress\n");
 267         }
 268
 269         return sock;
 270 }
 271
 272 /*
 273  * gg_read_line() // funkcja pomocnicza
 274  *
 275  * czyta jedn± liniê tekstu z gniazda.
 276  *
 277  *  - sock - deskryptor gniazda
 278  *  - buf - wska¼nik do bufora
 279  *  - length - d³ugo¶æ bufora
 280  *
 281  * je¶li trafi na b³±d odczytu, zwraca NULL. inaczej zwraca buf.
 282  */
 283 char *gg_read_line(int sock, char *buf, int length)
 284 {
 285         int ret;
 286
 287         if (!buf || length < 0)
 288                 return NULL;
 289         for (; length > 1; buf++, length--) {
 290                 do {
 291                         if ((ret = read(sock, buf, 1)) == -1 && errno != EINTR) {
 292                                 gg_debug(GG_DEBUG_MISC, "// gg_read_line() error on read (errno=%d, %s)\n", errno, strerror(errno));
 293                                 *buf = 0;
 294                                 return NULL;
 295                         } else if (ret == 0) {
 296                                 gg_debug(GG_DEBUG_MISC, "// gg_read_line() eof reached\n");
 297                                 *buf = 0;
 298                                 return NULL;
 299                         }
 300                 } while (ret == -1 && errno == EINTR);
 301
 302                 if (*buf == '\n') {
 303                         buf++;
 304                         break;
 305                 }
 306         }
 307
 308         *buf = 0;
 309         return buf;
 310 }
 311
 312 /*
 313  * gg_chomp() // funkcja pomocnicza
 314  *
 315  * ucina "\r\n" lub "\n" z koñca linii.
 316  *
 317  *  - line - linia do przyciêcia
 318  */
 319 void gg_chomp(char *line)
 320 {
 321         if (!line || strlen(line) < 1)
 322                 return;
 323
 324         if (line[strlen(line) - 1] == '\n')
 325                 line[strlen(line) - 1] = 0;
 326         if (line[strlen(line) - 1] == '\r')
 327                 line[strlen(line) - 1] = 0;
 328 }
 329
 330 /*
 331  * gg_urlencode() // funkcja wewnêtrzna
 332  *
 333  * zamienia podany tekst na ci±g znaków do formularza http. przydaje siê
 334  * przy ró¿nych us³ugach katalogu publicznego.
 335  *
 336  *  - str - ci±g znaków do zakodowania
 337  *
 338  * zaalokowany bufor, który nale¿y pó¼niej zwolniæ albo NULL
 339  * w przypadku b³êdu.
 340  */
 341 char *gg_urlencode(const char *str)
 342 {
 343         char *q, *buf, hex[] = "0123456789abcdef";
 344         const char *p;
 345         unsigned int size = 0;
 346
 347         if (!str && !(str = strdup("")))
 348                 return NULL;
 349
 350         for (p = str; *p; p++, size++) {
 351                 if (!((*p >= 'a' && *p <= 'z') || (*p >= 'A' && *p <= 'Z') || (*p >= '0' && *p <= '9') || *p == ' ') || (*p == '@') || (*p == '.') || (*p == '-'))
 352                         size += 2;
 353         }
 354
 355         if (!(buf = malloc(size + 1)))
 356                 return NULL;
 357
 358         for (p = str, q = buf; *p; p++, q++) {
 359                 if ((*p >= 'a' && *p <= 'z') || (*p >= 'A' && *p <= 'Z') || (*p >= '0' && *p <= '9') || (*p == '@') || (*p == '.') || (*p == '-'))
 360                         *q = *p;
 361                 else {
 362                         if (*p == ' ')
 363                                 *q = '+';
 364                         else {
 365                                 *q++ = '%';
 366                                 *q++ = hex[*p >> 4 & 15];
 367                                 *q = hex[*p & 15];
 368                         }
 369                 }
 370         }
 371
 372         *q = 0;
 373
 374         return buf;
 375 }
 376
 377 /*
 378  * gg_http_hash() // funkcja wewnêtrzna
 379  *
 380  * funkcja licz±ca hash dla adresu e-mail, has³a i paru innych.
 381  *
 382  *  - format... - format kolejnych parametrów ('s' je¶li dany parametr jest
 383  *                ci±giem znaków lub 'u' je¶li numerem GG)
 384  *
 385  * hash wykorzystywany przy rejestracji i wszelkich manipulacjach w³asnego
 386  * wpisu w katalogu publicznym.
 387  */
 388 int gg_http_hash(const char *format, ...)
 389 {
 390         unsigned int a, c, i, j;
 391         va_list ap;
 392         int b = -1;
 393
 394         va_start(ap, format);
 395
 396         for (j = 0; j < strlen(format); j++) {
 397                 char *arg, buf[16];
 398
 399                 if (format[j] == 'u') {
 400                         snprintf(buf, sizeof(buf), "%d", va_arg(ap, uin_t));
 401                         arg = buf;
 402                 } else {
 403                         if (!(arg = va_arg(ap, char*)))
 404                                 arg = "";
 405                 }
 406
 407                 i = 0;
 408                 while ((c = (unsigned char) arg[i++]) != 0) {
 409                         a = (c ^ b) + (c << 8);
 410                         b = (a >> 24) | (a << 8);
 411                 }
 412         }
 413
 414         va_end(ap);
 415
 416         return (b < 0 ? -b : b);
 417 }
 418
 419 /*
 420  * gg_gethostbyname() // funkcja pomocnicza
 421  *
 422  * odpowiednik gethostbyname() u¿ywaj±cy gethostbyname_r(), gdy potrzebna
 423  * jest wielobie¿no¶æ. chwilowo korzysta ze zwyk³ego gethostbyname().
 424  *
 425  *  - hostname - nazwa serwera
 426  *
 427  * zaalokowany bufor, który nale¿y zwolniæ lub NULL w przypadku b³êdu.
 428  */
 429 struct hostent *gg_gethostbyname(const char *hostname)
 430 {
 431         /* XXX u¿yæ gethostbyname_r() */
 432
 433         struct hostent *hp, *hp2;
 434
 435         if (!(hp = gethostbyname(hostname)))
 436                 return NULL;
 437
 438         if (!(hp2 = calloc(1, sizeof(*hp))))
 439                 return NULL;
 440
 441         memcpy(hp2, hp, sizeof(*hp));
 442
 443         return hp2;
 444 }
 445
 446 #ifdef ASSIGN_SOCKETS_TO_THREADS
 447
 448 typedef struct gg_win32_thread {
 449         int id;
 450         int socket;
 451         struct gg_win32_thread *next;
 452 } gg_win32_thread;
 453
 454 struct gg_win32_thread *gg_win32_threads = 0;
 455
 456 /*
 457  * gg_win32_thread_socket() // funkcja pomocnicza, tylko dla win32
 458  *
 459  * zwraca deskryptor gniazda, które by³o ostatnio tworzone dla w±tku
 460  * o podanym identyfikatorze.
 461  *
 462  * je¶li na win32 przy po³±czeniach synchronicznych zapamiêtamy w jakim
 463  * w±tku uruchomili¶my funkcjê, która siê z czymkolwiek ³±czy, to z osobnego
 464  * w±tku mo¿emy anulowaæ po³±czenie poprzez gg_win32_thread_socket(watek, -1);
 465  *
 466  * - thread_id - id w±tku. je¶li jest równe 0, brany jest aktualny w±tek,
 467  *               je¶li równe -1, usuwa wpis o podanym sockecie.
 468  * - socket - deskryptor gniazda. je¶li równe 0, zwraca deskryptor gniazda
 469  *            dla podanego w±tku, je¶li równe -1, usuwa wpis, je¶li co¶
 470  *            innego, ustawia dla podanego w±tku dany numer deskryptora.
 471  *
 472  * je¶li socket jest równe 0, zwraca deskryptor gniazda dla podanego w±tku.
 473  */
 474 int gg_win32_thread_socket(int thread_id, int socket)
 475 {
 476         char close = (thread_id == -1) || socket == -1;
 477         gg_win32_thread *wsk = gg_win32_threads;
 478         gg_win32_thread **p_wsk = &gg_win32_threads;
 479
 480         if (!thread_id)
 481                 thread_id = GetCurrentThreadId();
 482
 483         while (wsk) {
 484                 if ((thread_id == -1 && wsk->socket == socket) || wsk->id == thread_id) {
 485                         if (close) {
 486                                 /* socket zostaje usuniety */
 487                                 closesocket(wsk->socket);
 488                                 *p_wsk = wsk->next;
 489                                 free(wsk);
 490                                 return 1;
 491                         } else if (!socket) {
 492                                 /* socket zostaje zwrocony */
 493                                 return wsk->socket;
 494                         } else {
 495                                 /* socket zostaje ustawiony */
 496                                 wsk->socket = socket;
 497                                 return socket;
 498                         }
 499                }
 500
 501                p_wsk = &(wsk->next);
 502                wsk = wsk->next;
 503         }
 504
 505         if (close && socket != -1)
 506                 closesocket(socket);
 507         if (close || !socket)
 508                 return 0;
 509
 510         /* Dodaje nowy element */
 511         wsk = malloc(sizeof(gg_win32_thread));
 512         wsk->id = thread_id;
 513         wsk->socket = socket;
 514         wsk->next = 0;
 515         *p_wsk = wsk;
 516
 517         return socket;
 518 }
 519
 520 #endif /* ASSIGN_SOCKETS_TO_THREADS */
 521
 522 static char gg_base64_charset[] =
 523         "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";
 524
 525 /*
 526  * gg_base64_encode()
 527  *
 528  * zapisuje ci±g znaków w base64.
 529  *
 530  *  - buf - ci±g znaków.
 531  *
 532  * zaalokowany bufor.
 533  */
 534 char *gg_base64_encode(const char *buf)
 535 {
 536         char *out, *res;
 537         unsigned int i = 0, j = 0, k = 0, len = strlen(buf);
 538
 539         res = out = malloc((len / 3 + 1) * 4 + 2);
 540
 541         if (!res)
 542                 return NULL;
 543
 544         while (j <= len) {
 545                 switch (i % 4) {
 546                         case 0:
 547                                 k = (buf[j] & 252) >> 2;
 548                                 break;
 549                         case 1:
 550                                 if (j < len)
 551                                         k = ((buf[j] & 3) << 4) | ((buf[j + 1] & 240) >> 4);
 552                                 else
 553                                         k = (buf[j] & 3) << 4;
 554
 555                                 j++;
 556                                 break;
 557                         case 2:
 558                                 if (j < len)
 559                                         k = ((buf[j] & 15) << 2) | ((buf[j + 1] & 192) >> 6);
 560                                 else
 561                                         k = (buf[j] & 15) << 2;
 562
 563                                 j++;
 564                                 break;
 565                         case 3:
 566                                 k = buf[j++] & 63;
 567                                 break;
 568                 }
 569                 *out++ = gg_base64_charset[k];
 570                 i++;
 571         }
 572
 573         if (i % 4)
 574                 for (j = 0; j < 4 - (i % 4); j++, out++)
 575                         *out = '=';
 576
 577         *out = 0;
 578
 579         return res;
 580 }
 581
 582 /*
 583  * gg_base64_decode()
 584  *
 585  * dekoduje ci±g znaków z base64.
 586  *
 587  *  - buf - ci±g znaków.
 588  *
 589  * zaalokowany bufor.
 590  */
 591 char *gg_base64_decode(const char *buf)
 592 {
 593         char *res, *save, *foo, val;
 594         const char *end;
 595         unsigned int index = 0;
 596
 597         if (!buf)
 598                 return NULL;
 599
 600         save = res = calloc(1, (strlen(buf) / 4 + 1) * 3 + 2);
 601
 602         if (!save)
 603                 return NULL;
 604
 605         end = buf + strlen(buf);
 606
 607         while (*buf && buf < end) {
 608                 if (*buf == '\r' || *buf == '\n') {
 609                         buf++;
 610                         continue;
 611                 }
 612                 if (!(foo = strchr(gg_base64_charset, *buf)))
 613                         foo = gg_base64_charset;
 614                 val = (int)(foo - gg_base64_charset);
 615                 buf++;
 616                 switch (index) {
 617                         case 0:
 618                                 *res |= val << 2;
 619                                 break;
 620                         case 1:
 621                                 *res++ |= val >> 4;
 622                                 *res |= val << 4;
 623                                 break;
 624                         case 2:
 625                                 *res++ |= val >> 2;
 626                                 *res |= val << 6;
 627                                 break;
 628                         case 3:
 629                                 *res++ |= val;
 630                                 break;
 631                 }
 632                 index++;
 633                 index %= 4;
 634         }
 635         *res = 0;
 636
 637         return save;
 638 }
 639
 640 /*
 641  * gg_proxy_auth() // funkcja wewnêtrzna
 642  *
 643  * tworzy nag³ówek autoryzacji dla proxy.
 644  *
 645  * zaalokowany tekst lub NULL, je¶li proxy nie jest w³±czone lub nie wymaga
 646  * autoryzacji.
 647  */
 648 char *gg_proxy_auth()
 649 {
 650         char *tmp, *enc, *out;
 651         unsigned int tmp_size;
 652
 653         if (!gg_proxy_enabled || !gg_proxy_username || !gg_proxy_password)
 654                 return NULL;
 655
 656         if (!(tmp = malloc((tmp_size = strlen(gg_proxy_username) + strlen(gg_proxy_password) + 2))))
 657                 return NULL;
 658
 659         snprintf(tmp, tmp_size, "%s:%s", gg_proxy_username, gg_proxy_password);
 660
 661         if (!(enc = gg_base64_encode(tmp))) {
 662                 free(tmp);
 663                 return NULL;
 664         }
 665
 666         free(tmp);
 667
 668         if (!(out = malloc(strlen(enc) + 40))) {
 669                 free(enc);
 670                 return NULL;
 671         }
 672
 673         snprintf(out, strlen(enc) + 40,  "Proxy-Authorization: Basic %s\r\n", enc);
 674
 675         free(enc);
 676
 677         return out;
 678 }
 679
 680 static uint32_t gg_crc32_table[256];
 681 static int gg_crc32_initialized = 0;
 682
 683 /*
 684  * gg_crc32_make_table()  // funkcja wewnêtrzna
 685  */
 686 static void gg_crc32_make_table()
 687 {
 688         uint32_t h = 0;
 689         unsigned int i, j;
 690
 691         memset(gg_crc32_table, 0, sizeof(gg_crc32_table));
 692
 693         for (i = 128; i; i >>= 1) {
 694                 h = (h >> 1) ^ ((h & 1) ? 0xedb88320L : 0);
 695
 696                 for (j = 0; j < 256; j += 2 * i)
 697                         gg_crc32_table[i + j] = gg_crc32_table[j] ^ h;
 698         }
 699
 700         gg_crc32_initialized = 1;
 701 }
 702
 703 /*
 704  * gg_crc32()
 705  *
 706  * wyznacza sumê kontroln± CRC32 danego bloku danych.
 707  *
 708  *  - crc - suma kontrola poprzedniego bloku danych lub 0 je¶li pierwszy
 709  *  - buf - bufor danych
 710  *  - size - ilo¶æ danych
 711  *
 712  * suma kontrolna CRC32.
 713  */
 714 uint32_t gg_crc32(uint32_t crc, const unsigned char *buf, int len)
 715 {
 716         if (!gg_crc32_initialized)
 717                 gg_crc32_make_table();
 718         if (!buf || len < 0)
 719                 return crc;
 720
 721         crc ^= 0xffffffffL;
 722
 723         while (len--)
 724                 crc = (crc >> 8) ^ gg_crc32_table[(crc ^ *buf++) & 0xff];
 725
 726         return crc ^ 0xffffffffL;
 727 }
 728
 729
 730 /*
 731  * Local variables:
 732  * c-indentation-style: k&r
 733  * c-basic-offset: 8
 734  * indent-tabs-mode: notnil
 735  * End:
 736  *
 737  * vim: shiftwidth=8:
 738  */