Annotation of embedaddon/curl/packages/OS400/os400sys.c, revision 1.1
1.1 ! misho 1: /***************************************************************************
! 2: * _ _ ____ _
! 3: * Project ___| | | | _ \| |
! 4: * / __| | | | |_) | |
! 5: * | (__| |_| | _ <| |___
! 6: * \___|\___/|_| \_\_____|
! 7: *
! 8: * Copyright (C) 1998 - 2019, Daniel Stenberg, <daniel@haxx.se>, et al.
! 9: *
! 10: * This software is licensed as described in the file COPYING, which
! 11: * you should have received as part of this distribution. The terms
! 12: * are also available at https://curl.haxx.se/docs/copyright.html.
! 13: *
! 14: * You may opt to use, copy, modify, merge, publish, distribute and/or sell
! 15: * copies of the Software, and permit persons to whom the Software is
! 16: * furnished to do so, under the terms of the COPYING file.
! 17: *
! 18: * This software is distributed on an "AS IS" basis, WITHOUT WARRANTY OF ANY
! 19: * KIND, either express or implied.
! 20: *
! 21: *
! 22: ***************************************************************************/
! 23:
! 24: /* OS/400 additional support. */
! 25:
! 26: #include <curl/curl.h>
! 27: #include "config-os400.h" /* Not curl_setup.h: we only need some defines. */
! 28:
! 29: #include <sys/types.h>
! 30: #include <sys/socket.h>
! 31: #include <sys/un.h>
! 32:
! 33: #include <stdlib.h>
! 34: #include <stddef.h>
! 35: #include <string.h>
! 36: #include <pthread.h>
! 37: #include <netdb.h>
! 38: #include <qadrt.h>
! 39: #include <errno.h>
! 40:
! 41: #ifdef HAVE_ZLIB_H
! 42: #include <zlib.h>
! 43: #endif
! 44:
! 45: #ifdef USE_GSKIT
! 46: #include <gskssl.h>
! 47: #include <qsoasync.h>
! 48: #endif
! 49:
! 50: #ifdef HAVE_GSSAPI
! 51: #include <gssapi.h>
! 52: #endif
! 53:
! 54: #ifndef CURL_DISABLE_LDAP
! 55: #include <ldap.h>
! 56: #endif
! 57:
! 58: #include <netinet/in.h>
! 59: #include <arpa/inet.h>
! 60:
! 61: #include "os400sys.h"
! 62:
! 63:
! 64: /**
! 65: *** QADRT OS/400 ASCII runtime defines only the most used procedures, but
! 66: *** but a lot of them are not supported. This module implements
! 67: *** ASCII wrappers for those that are used by libcurl, but not
! 68: *** defined by QADRT.
! 69: **/
! 70:
! 71: #pragma convert(0) /* Restore EBCDIC. */
! 72:
! 73:
! 74: #define MIN_BYTE_GAIN 1024 /* Minimum gain when shortening a buffer. */
! 75:
! 76: typedef struct {
! 77: unsigned long size; /* Buffer size. */
! 78: char * buf; /* Buffer address. */
! 79: } buffer_t;
! 80:
! 81:
! 82: static char * buffer_undef(localkey_t key, long size);
! 83: static char * buffer_threaded(localkey_t key, long size);
! 84: static char * buffer_unthreaded(localkey_t key, long size);
! 85:
! 86: static pthread_mutex_t mutex = PTHREAD_MUTEX_INITIALIZER;
! 87: static pthread_key_t thdkey;
! 88: static buffer_t * locbufs;
! 89:
! 90: char * (* Curl_thread_buffer)(localkey_t key, long size) = buffer_undef;
! 91:
! 92:
! 93: static void
! 94: thdbufdestroy(void * private)
! 95:
! 96: {
! 97: if(private) {
! 98: buffer_t * p = (buffer_t *) private;
! 99: localkey_t i;
! 100:
! 101: for(i = (localkey_t) 0; i < LK_LAST; i++) {
! 102: free(p->buf);
! 103: p++;
! 104: }
! 105:
! 106: free(private);
! 107: }
! 108: }
! 109:
! 110:
! 111: static void
! 112: terminate(void)
! 113:
! 114: {
! 115: if(Curl_thread_buffer == buffer_threaded) {
! 116: locbufs = pthread_getspecific(thdkey);
! 117: pthread_setspecific(thdkey, (void *) NULL);
! 118: pthread_key_delete(thdkey);
! 119: }
! 120:
! 121: if(Curl_thread_buffer != buffer_undef) {
! 122: thdbufdestroy((void *) locbufs);
! 123: locbufs = (buffer_t *) NULL;
! 124: }
! 125:
! 126: Curl_thread_buffer = buffer_undef;
! 127: }
! 128:
! 129:
! 130: static char *
! 131: get_buffer(buffer_t * buf, long size)
! 132:
! 133: {
! 134: char * cp;
! 135:
! 136: /* If `size' >= 0, make sure buffer at `buf' is at least `size'-byte long.
! 137: Return the buffer address. */
! 138:
! 139: if(size < 0)
! 140: return buf->buf;
! 141:
! 142: if(!buf->buf) {
! 143: buf->buf = malloc(size);
! 144: if(buf->buf)
! 145: buf->size = size;
! 146:
! 147: return buf->buf;
! 148: }
! 149:
! 150: if((unsigned long) size <= buf->size) {
! 151: /* Shorten the buffer only if it frees a significant byte count. This
! 152: avoids some realloc() overhead. */
! 153:
! 154: if(buf->size - size < MIN_BYTE_GAIN)
! 155: return buf->buf;
! 156: }
! 157:
! 158: /* Resize the buffer. */
! 159:
! 160: cp = realloc(buf->buf, size);
! 161: if(cp) {
! 162: buf->buf = cp;
! 163: buf->size = size;
! 164: }
! 165: else if(size <= buf->size)
! 166: cp = buf->buf;
! 167:
! 168: return cp;
! 169: }
! 170:
! 171:
! 172: static char *
! 173: buffer_unthreaded(localkey_t key, long size)
! 174:
! 175: {
! 176: return get_buffer(locbufs + key, size);
! 177: }
! 178:
! 179:
! 180: static char *
! 181: buffer_threaded(localkey_t key, long size)
! 182:
! 183: {
! 184: buffer_t * bufs;
! 185:
! 186: /* Get the buffer for the given local key in the current thread, and
! 187: make sure it is at least `size'-byte long. Set `size' to < 0 to get
! 188: its address only. */
! 189:
! 190: bufs = (buffer_t *) pthread_getspecific(thdkey);
! 191:
! 192: if(!bufs) {
! 193: if(size < 0)
! 194: return (char *) NULL; /* No buffer yet. */
! 195:
! 196: /* Allocate buffer descriptors for the current thread. */
! 197:
! 198: bufs = calloc((size_t) LK_LAST, sizeof(*bufs));
! 199: if(!bufs)
! 200: return (char *) NULL;
! 201:
! 202: if(pthread_setspecific(thdkey, (void *) bufs)) {
! 203: free(bufs);
! 204: return (char *) NULL;
! 205: }
! 206: }
! 207:
! 208: return get_buffer(bufs + key, size);
! 209: }
! 210:
! 211:
! 212: static char *
! 213: buffer_undef(localkey_t key, long size)
! 214:
! 215: {
! 216: /* Define the buffer system, get the buffer for the given local key in
! 217: the current thread, and make sure it is at least `size'-byte long.
! 218: Set `size' to < 0 to get its address only. */
! 219:
! 220: pthread_mutex_lock(&mutex);
! 221:
! 222: /* Determine if we can use pthread-specific data. */
! 223:
! 224: if(Curl_thread_buffer == buffer_undef) { /* If unchanged during lock. */
! 225: if(!pthread_key_create(&thdkey, thdbufdestroy))
! 226: Curl_thread_buffer = buffer_threaded;
! 227: else if(!(locbufs = calloc((size_t) LK_LAST, sizeof(*locbufs)))) {
! 228: pthread_mutex_unlock(&mutex);
! 229: return (char *) NULL;
! 230: }
! 231: else
! 232: Curl_thread_buffer = buffer_unthreaded;
! 233:
! 234: atexit(terminate);
! 235: }
! 236:
! 237: pthread_mutex_unlock(&mutex);
! 238: return Curl_thread_buffer(key, size);
! 239: }
! 240:
! 241:
! 242: static char *
! 243: set_thread_string(localkey_t key, const char * s)
! 244:
! 245: {
! 246: int i;
! 247: char * cp;
! 248:
! 249: if(!s)
! 250: return (char *) NULL;
! 251:
! 252: i = strlen(s) + 1;
! 253: cp = Curl_thread_buffer(key, MAX_CONV_EXPANSION * i + 1);
! 254:
! 255: if(cp) {
! 256: i = QadrtConvertE2A(cp, s, MAX_CONV_EXPANSION * i, i);
! 257: cp[i] = '\0';
! 258: }
! 259:
! 260: return cp;
! 261: }
! 262:
! 263:
! 264: int
! 265: Curl_getnameinfo_a(const struct sockaddr * sa, curl_socklen_t salen,
! 266: char * nodename, curl_socklen_t nodenamelen,
! 267: char * servname, curl_socklen_t servnamelen,
! 268: int flags)
! 269:
! 270: {
! 271: char *enodename = NULL;
! 272: char *eservname = NULL;
! 273: int status;
! 274:
! 275: if(nodename && nodenamelen) {
! 276: enodename = malloc(nodenamelen);
! 277: if(!enodename)
! 278: return EAI_MEMORY;
! 279: }
! 280:
! 281: if(servname && servnamelen) {
! 282: eservname = malloc(servnamelen);
! 283: if(!eservname) {
! 284: free(enodename);
! 285: return EAI_MEMORY;
! 286: }
! 287: }
! 288:
! 289: status = getnameinfo(sa, salen, enodename, nodenamelen,
! 290: eservname, servnamelen, flags);
! 291:
! 292: if(!status) {
! 293: int i;
! 294: if(enodename) {
! 295: i = QadrtConvertE2A(nodename, enodename,
! 296: nodenamelen - 1, strlen(enodename));
! 297: nodename[i] = '\0';
! 298: }
! 299:
! 300: if(eservname) {
! 301: i = QadrtConvertE2A(servname, eservname,
! 302: servnamelen - 1, strlen(eservname));
! 303: servname[i] = '\0';
! 304: }
! 305: }
! 306:
! 307: free(enodename);
! 308: free(eservname);
! 309: return status;
! 310: }
! 311:
! 312:
! 313: int
! 314: Curl_getaddrinfo_a(const char * nodename, const char * servname,
! 315: const struct addrinfo * hints,
! 316: struct addrinfo * * res)
! 317:
! 318: {
! 319: char * enodename;
! 320: char * eservname;
! 321: int status;
! 322: int i;
! 323:
! 324: enodename = (char *) NULL;
! 325: eservname = (char *) NULL;
! 326:
! 327: if(nodename) {
! 328: i = strlen(nodename);
! 329:
! 330: enodename = malloc(i + 1);
! 331: if(!enodename)
! 332: return EAI_MEMORY;
! 333:
! 334: i = QadrtConvertA2E(enodename, nodename, i, i);
! 335: enodename[i] = '\0';
! 336: }
! 337:
! 338: if(servname) {
! 339: i = strlen(servname);
! 340:
! 341: eservname = malloc(i + 1);
! 342: if(!eservname) {
! 343: free(enodename);
! 344: return EAI_MEMORY;
! 345: }
! 346:
! 347: QadrtConvertA2E(eservname, servname, i, i);
! 348: eservname[i] = '\0';
! 349: }
! 350:
! 351: status = getaddrinfo(enodename, eservname, hints, res);
! 352: free(enodename);
! 353: free(eservname);
! 354: return status;
! 355: }
! 356:
! 357:
! 358: #ifdef USE_GSKIT
! 359:
! 360: /* ASCII wrappers for the GSKit procedures. */
! 361:
! 362: /*
! 363: * EBCDIC --> ASCII string mapping table.
! 364: * Some strings returned by GSKit are dynamically allocated and automatically
! 365: * released when closing the handle.
! 366: * To provide the same functionality, we use a "private" handle that
! 367: * holds the GSKit handle and a list of string mappings. This will allow
! 368: * avoid conversion of already converted strings and releasing them upon
! 369: * close time.
! 370: */
! 371:
! 372: struct gskstrlist {
! 373: struct gskstrlist * next;
! 374: const char * ebcdicstr;
! 375: const char * asciistr;
! 376: };
! 377:
! 378: struct Curl_gsk_descriptor {
! 379: gsk_handle h;
! 380: struct gskstrlist * strlist;
! 381: };
! 382:
! 383:
! 384: int
! 385: Curl_gsk_environment_open(gsk_handle * my_env_handle)
! 386:
! 387: {
! 388: struct Curl_gsk_descriptor * p;
! 389: int rc;
! 390:
! 391: if(!my_env_handle)
! 392: return GSK_OS400_ERROR_INVALID_POINTER;
! 393: p = (struct Curl_gsk_descriptor *) malloc(sizeof(*p));
! 394: if(!p)
! 395: return GSK_INSUFFICIENT_STORAGE;
! 396: p->strlist = (struct gskstrlist *) NULL;
! 397: rc = gsk_environment_open(&p->h);
! 398: if(rc != GSK_OK)
! 399: free(p);
! 400: else
! 401: *my_env_handle = (gsk_handle) p;
! 402: return rc;
! 403: }
! 404:
! 405:
! 406: int
! 407: Curl_gsk_secure_soc_open(gsk_handle my_env_handle,
! 408: gsk_handle * my_session_handle)
! 409:
! 410: {
! 411: struct Curl_gsk_descriptor * p;
! 412: gsk_handle h;
! 413: int rc;
! 414:
! 415: if(!my_env_handle)
! 416: return GSK_INVALID_HANDLE;
! 417: if(!my_session_handle)
! 418: return GSK_OS400_ERROR_INVALID_POINTER;
! 419: h = ((struct Curl_gsk_descriptor *) my_env_handle)->h;
! 420: p = (struct Curl_gsk_descriptor *) malloc(sizeof(*p));
! 421: if(!p)
! 422: return GSK_INSUFFICIENT_STORAGE;
! 423: p->strlist = (struct gskstrlist *) NULL;
! 424: rc = gsk_secure_soc_open(h, &p->h);
! 425: if(rc != GSK_OK)
! 426: free(p);
! 427: else
! 428: *my_session_handle = (gsk_handle) p;
! 429: return rc;
! 430: }
! 431:
! 432:
! 433: static void
! 434: gsk_free_handle(struct Curl_gsk_descriptor * p)
! 435:
! 436: {
! 437: struct gskstrlist * q;
! 438:
! 439: while((q = p->strlist)) {
! 440: p->strlist = q;
! 441: free((void *) q->asciistr);
! 442: free(q);
! 443: }
! 444: free(p);
! 445: }
! 446:
! 447:
! 448: int
! 449: Curl_gsk_environment_close(gsk_handle * my_env_handle)
! 450:
! 451: {
! 452: struct Curl_gsk_descriptor * p;
! 453: int rc;
! 454:
! 455: if(!my_env_handle)
! 456: return GSK_OS400_ERROR_INVALID_POINTER;
! 457: if(!*my_env_handle)
! 458: return GSK_INVALID_HANDLE;
! 459: p = (struct Curl_gsk_descriptor *) *my_env_handle;
! 460: rc = gsk_environment_close(&p->h);
! 461: if(rc == GSK_OK) {
! 462: gsk_free_handle(p);
! 463: *my_env_handle = (gsk_handle) NULL;
! 464: }
! 465: return rc;
! 466: }
! 467:
! 468:
! 469: int
! 470: Curl_gsk_secure_soc_close(gsk_handle * my_session_handle)
! 471:
! 472: {
! 473: struct Curl_gsk_descriptor * p;
! 474: int rc;
! 475:
! 476: if(!my_session_handle)
! 477: return GSK_OS400_ERROR_INVALID_POINTER;
! 478: if(!*my_session_handle)
! 479: return GSK_INVALID_HANDLE;
! 480: p = (struct Curl_gsk_descriptor *) *my_session_handle;
! 481: rc = gsk_secure_soc_close(&p->h);
! 482: if(rc == GSK_OK) {
! 483: gsk_free_handle(p);
! 484: *my_session_handle = (gsk_handle) NULL;
! 485: }
! 486: return rc;
! 487: }
! 488:
! 489:
! 490: int
! 491: Curl_gsk_environment_init(gsk_handle my_env_handle)
! 492:
! 493: {
! 494: struct Curl_gsk_descriptor * p;
! 495:
! 496: if(!my_env_handle)
! 497: return GSK_INVALID_HANDLE;
! 498: p = (struct Curl_gsk_descriptor *) my_env_handle;
! 499: return gsk_environment_init(p->h);
! 500: }
! 501:
! 502:
! 503: int
! 504: Curl_gsk_secure_soc_init(gsk_handle my_session_handle)
! 505:
! 506: {
! 507: struct Curl_gsk_descriptor * p;
! 508:
! 509: if(!my_session_handle)
! 510: return GSK_INVALID_HANDLE;
! 511: p = (struct Curl_gsk_descriptor *) my_session_handle;
! 512: return gsk_secure_soc_init(p->h);
! 513: }
! 514:
! 515:
! 516: int
! 517: Curl_gsk_attribute_set_buffer_a(gsk_handle my_gsk_handle, GSK_BUF_ID bufID,
! 518: const char * buffer, int bufSize)
! 519:
! 520: {
! 521: struct Curl_gsk_descriptor * p;
! 522: char * ebcdicbuf;
! 523: int rc;
! 524:
! 525: if(!my_gsk_handle)
! 526: return GSK_INVALID_HANDLE;
! 527: if(!buffer)
! 528: return GSK_OS400_ERROR_INVALID_POINTER;
! 529: if(bufSize < 0)
! 530: return GSK_ATTRIBUTE_INVALID_LENGTH;
! 531: p = (struct Curl_gsk_descriptor *) my_gsk_handle;
! 532: if(!bufSize)
! 533: bufSize = strlen(buffer);
! 534: ebcdicbuf = malloc(bufSize + 1);
! 535: if(!ebcdicbuf)
! 536: return GSK_INSUFFICIENT_STORAGE;
! 537: QadrtConvertA2E(ebcdicbuf, buffer, bufSize, bufSize);
! 538: ebcdicbuf[bufSize] = '\0';
! 539: rc = gsk_attribute_set_buffer(p->h, bufID, ebcdicbuf, bufSize);
! 540: free(ebcdicbuf);
! 541: return rc;
! 542: }
! 543:
! 544:
! 545: int
! 546: Curl_gsk_attribute_set_enum(gsk_handle my_gsk_handle, GSK_ENUM_ID enumID,
! 547: GSK_ENUM_VALUE enumValue)
! 548:
! 549: {
! 550: struct Curl_gsk_descriptor * p;
! 551:
! 552: if(!my_gsk_handle)
! 553: return GSK_INVALID_HANDLE;
! 554: p = (struct Curl_gsk_descriptor *) my_gsk_handle;
! 555: return gsk_attribute_set_enum(p->h, enumID, enumValue);
! 556: }
! 557:
! 558:
! 559: int
! 560: Curl_gsk_attribute_set_numeric_value(gsk_handle my_gsk_handle,
! 561: GSK_NUM_ID numID, int numValue)
! 562:
! 563: {
! 564: struct Curl_gsk_descriptor * p;
! 565:
! 566: if(!my_gsk_handle)
! 567: return GSK_INVALID_HANDLE;
! 568: p = (struct Curl_gsk_descriptor *) my_gsk_handle;
! 569: return gsk_attribute_set_numeric_value(p->h, numID, numValue);
! 570: }
! 571:
! 572:
! 573: int
! 574: Curl_gsk_attribute_set_callback(gsk_handle my_gsk_handle,
! 575: GSK_CALLBACK_ID callBackID,
! 576: void * callBackAreaPtr)
! 577:
! 578: {
! 579: struct Curl_gsk_descriptor * p;
! 580:
! 581: if(!my_gsk_handle)
! 582: return GSK_INVALID_HANDLE;
! 583: p = (struct Curl_gsk_descriptor *) my_gsk_handle;
! 584: return gsk_attribute_set_callback(p->h, callBackID, callBackAreaPtr);
! 585: }
! 586:
! 587:
! 588: static int
! 589: cachestring(struct Curl_gsk_descriptor * p,
! 590: const char * ebcdicbuf, int bufsize, const char * * buffer)
! 591:
! 592: {
! 593: int rc;
! 594: char * asciibuf;
! 595: struct gskstrlist * sp;
! 596:
! 597: for(sp = p->strlist; sp; sp = sp->next)
! 598: if(sp->ebcdicstr == ebcdicbuf)
! 599: break;
! 600: if(!sp) {
! 601: sp = (struct gskstrlist *) malloc(sizeof(*sp));
! 602: if(!sp)
! 603: return GSK_INSUFFICIENT_STORAGE;
! 604: asciibuf = malloc(bufsize + 1);
! 605: if(!asciibuf) {
! 606: free(sp);
! 607: return GSK_INSUFFICIENT_STORAGE;
! 608: }
! 609: QadrtConvertE2A(asciibuf, ebcdicbuf, bufsize, bufsize);
! 610: asciibuf[bufsize] = '\0';
! 611: sp->ebcdicstr = ebcdicbuf;
! 612: sp->asciistr = asciibuf;
! 613: sp->next = p->strlist;
! 614: p->strlist = sp;
! 615: }
! 616: *buffer = sp->asciistr;
! 617: return GSK_OK;
! 618: }
! 619:
! 620:
! 621: int
! 622: Curl_gsk_attribute_get_buffer_a(gsk_handle my_gsk_handle, GSK_BUF_ID bufID,
! 623: const char * * buffer, int * bufSize)
! 624:
! 625: {
! 626: struct Curl_gsk_descriptor * p;
! 627: int rc;
! 628: const char * mybuf;
! 629: int mylen;
! 630:
! 631: if(!my_gsk_handle)
! 632: return GSK_INVALID_HANDLE;
! 633: if(!buffer || !bufSize)
! 634: return GSK_OS400_ERROR_INVALID_POINTER;
! 635: p = (struct Curl_gsk_descriptor *) my_gsk_handle;
! 636: rc = gsk_attribute_get_buffer(p->h, bufID, &mybuf, &mylen);
! 637: if(rc != GSK_OK)
! 638: return rc;
! 639: rc = cachestring(p, mybuf, mylen, buffer);
! 640: if(rc == GSK_OK)
! 641: *bufSize = mylen;
! 642: return rc;
! 643: }
! 644:
! 645:
! 646: int
! 647: Curl_gsk_attribute_get_enum(gsk_handle my_gsk_handle, GSK_ENUM_ID enumID,
! 648: GSK_ENUM_VALUE * enumValue)
! 649:
! 650: {
! 651: struct Curl_gsk_descriptor * p;
! 652:
! 653: if(!my_gsk_handle)
! 654: return GSK_INVALID_HANDLE;
! 655: p = (struct Curl_gsk_descriptor *) my_gsk_handle;
! 656: return gsk_attribute_get_enum(p->h, enumID, enumValue);
! 657: }
! 658:
! 659:
! 660: int
! 661: Curl_gsk_attribute_get_numeric_value(gsk_handle my_gsk_handle,
! 662: GSK_NUM_ID numID, int * numValue)
! 663:
! 664: {
! 665: struct Curl_gsk_descriptor * p;
! 666:
! 667: if(!my_gsk_handle)
! 668: return GSK_INVALID_HANDLE;
! 669: p = (struct Curl_gsk_descriptor *) my_gsk_handle;
! 670: return gsk_attribute_get_numeric_value(p->h, numID, numValue);
! 671: }
! 672:
! 673:
! 674: int
! 675: Curl_gsk_attribute_get_cert_info(gsk_handle my_gsk_handle,
! 676: GSK_CERT_ID certID,
! 677: const gsk_cert_data_elem * * certDataElem,
! 678: int * certDataElementCount)
! 679:
! 680: {
! 681: struct Curl_gsk_descriptor * p;
! 682:
! 683: if(!my_gsk_handle)
! 684: return GSK_INVALID_HANDLE;
! 685: p = (struct Curl_gsk_descriptor *) my_gsk_handle;
! 686: /* No need to convert code: text results are already in ASCII. */
! 687: return gsk_attribute_get_cert_info(p->h, certID,
! 688: certDataElem, certDataElementCount);
! 689: }
! 690:
! 691:
! 692: int
! 693: Curl_gsk_secure_soc_misc(gsk_handle my_session_handle, GSK_MISC_ID miscID)
! 694:
! 695: {
! 696: struct Curl_gsk_descriptor * p;
! 697:
! 698: if(!my_session_handle)
! 699: return GSK_INVALID_HANDLE;
! 700: p = (struct Curl_gsk_descriptor *) my_session_handle;
! 701: return gsk_secure_soc_misc(p->h, miscID);
! 702: }
! 703:
! 704:
! 705: int
! 706: Curl_gsk_secure_soc_read(gsk_handle my_session_handle, char * readBuffer,
! 707: int readBufSize, int * amtRead)
! 708:
! 709: {
! 710: struct Curl_gsk_descriptor * p;
! 711:
! 712: if(!my_session_handle)
! 713: return GSK_INVALID_HANDLE;
! 714: p = (struct Curl_gsk_descriptor *) my_session_handle;
! 715: return gsk_secure_soc_read(p->h, readBuffer, readBufSize, amtRead);
! 716: }
! 717:
! 718:
! 719: int
! 720: Curl_gsk_secure_soc_write(gsk_handle my_session_handle, char * writeBuffer,
! 721: int writeBufSize, int * amtWritten)
! 722:
! 723: {
! 724: struct Curl_gsk_descriptor * p;
! 725:
! 726: if(!my_session_handle)
! 727: return GSK_INVALID_HANDLE;
! 728: p = (struct Curl_gsk_descriptor *) my_session_handle;
! 729: return gsk_secure_soc_write(p->h, writeBuffer, writeBufSize, amtWritten);
! 730: }
! 731:
! 732:
! 733: const char *
! 734: Curl_gsk_strerror_a(int gsk_return_value)
! 735:
! 736: {
! 737: return set_thread_string(LK_GSK_ERROR, gsk_strerror(gsk_return_value));
! 738: }
! 739:
! 740: int
! 741: Curl_gsk_secure_soc_startInit(gsk_handle my_session_handle,
! 742: int IOCompletionPort,
! 743: Qso_OverlappedIO_t * communicationsArea)
! 744:
! 745: {
! 746: struct Curl_gsk_descriptor * p;
! 747:
! 748: if(!my_session_handle)
! 749: return GSK_INVALID_HANDLE;
! 750: p = (struct Curl_gsk_descriptor *) my_session_handle;
! 751: return gsk_secure_soc_startInit(p->h, IOCompletionPort, communicationsArea);
! 752: }
! 753:
! 754: #endif /* USE_GSKIT */
! 755:
! 756:
! 757:
! 758: #ifdef HAVE_GSSAPI
! 759:
! 760: /* ASCII wrappers for the GSSAPI procedures. */
! 761:
! 762: static int
! 763: Curl_gss_convert_in_place(OM_uint32 * minor_status, gss_buffer_t buf)
! 764:
! 765: {
! 766: unsigned int i = buf->length;
! 767:
! 768: /* Convert `buf' in place, from EBCDIC to ASCII.
! 769: If error, release the buffer and return -1. Else return 0. */
! 770:
! 771: if(i) {
! 772: char *t = malloc(i);
! 773: if(!t) {
! 774: gss_release_buffer(minor_status, buf);
! 775:
! 776: if(minor_status)
! 777: *minor_status = ENOMEM;
! 778:
! 779: return -1;
! 780: }
! 781:
! 782: QadrtConvertE2A(t, buf->value, i, i);
! 783: memcpy(buf->value, t, i);
! 784: free(t);
! 785: }
! 786:
! 787: return 0;
! 788: }
! 789:
! 790:
! 791: OM_uint32
! 792: Curl_gss_import_name_a(OM_uint32 * minor_status, gss_buffer_t in_name,
! 793: gss_OID in_name_type, gss_name_t * out_name)
! 794:
! 795: {
! 796: int rc;
! 797: unsigned int i;
! 798: gss_buffer_desc in;
! 799:
! 800: if(!in_name || !in_name->value || !in_name->length)
! 801: return gss_import_name(minor_status, in_name, in_name_type, out_name);
! 802:
! 803: memcpy((char *) &in, (char *) in_name, sizeof(in));
! 804: i = in.length;
! 805:
! 806: in.value = malloc(i + 1);
! 807: if(!in.value) {
! 808: if(minor_status)
! 809: *minor_status = ENOMEM;
! 810:
! 811: return GSS_S_FAILURE;
! 812: }
! 813:
! 814: QadrtConvertA2E(in.value, in_name->value, i, i);
! 815: ((char *) in.value)[i] = '\0';
! 816: rc = gss_import_name(minor_status, &in, in_name_type, out_name);
! 817: free(in.value);
! 818: return rc;
! 819: }
! 820:
! 821:
! 822: OM_uint32
! 823: Curl_gss_display_status_a(OM_uint32 * minor_status, OM_uint32 status_value,
! 824: int status_type, gss_OID mech_type,
! 825: gss_msg_ctx_t * message_context, gss_buffer_t status_string)
! 826:
! 827: {
! 828: int rc;
! 829:
! 830: rc = gss_display_status(minor_status, status_value, status_type,
! 831: mech_type, message_context, status_string);
! 832:
! 833: if(rc != GSS_S_COMPLETE || !status_string ||
! 834: !status_string->length || !status_string->value)
! 835: return rc;
! 836:
! 837: /* No way to allocate a buffer here, because it will be released by
! 838: gss_release_buffer(). The solution is to overwrite the EBCDIC buffer
! 839: with ASCII to return it. */
! 840:
! 841: if(Curl_gss_convert_in_place(minor_status, status_string))
! 842: return GSS_S_FAILURE;
! 843:
! 844: return rc;
! 845: }
! 846:
! 847:
! 848: OM_uint32
! 849: Curl_gss_init_sec_context_a(OM_uint32 * minor_status,
! 850: gss_cred_id_t cred_handle,
! 851: gss_ctx_id_t * context_handle,
! 852: gss_name_t target_name, gss_OID mech_type,
! 853: gss_flags_t req_flags, OM_uint32 time_req,
! 854: gss_channel_bindings_t input_chan_bindings,
! 855: gss_buffer_t input_token,
! 856: gss_OID * actual_mech_type,
! 857: gss_buffer_t output_token, gss_flags_t * ret_flags,
! 858: OM_uint32 * time_rec)
! 859:
! 860: {
! 861: int rc;
! 862: gss_buffer_desc in;
! 863: gss_buffer_t inp;
! 864:
! 865: in.value = NULL;
! 866: inp = input_token;
! 867:
! 868: if(inp) {
! 869: if(inp->length && inp->value) {
! 870: unsigned int i = inp->length;
! 871:
! 872: in.value = malloc(i + 1);
! 873: if(!in.value) {
! 874: if(minor_status)
! 875: *minor_status = ENOMEM;
! 876:
! 877: return GSS_S_FAILURE;
! 878: }
! 879:
! 880: QadrtConvertA2E(in.value, input_token->value, i, i);
! 881: ((char *) in.value)[i] = '\0';
! 882: in.length = i;
! 883: inp = ∈
! 884: }
! 885: }
! 886:
! 887: rc = gss_init_sec_context(minor_status, cred_handle, context_handle,
! 888: target_name, mech_type, req_flags, time_req,
! 889: input_chan_bindings, inp, actual_mech_type,
! 890: output_token, ret_flags, time_rec);
! 891: free(in.value);
! 892:
! 893: if(rc != GSS_S_COMPLETE || !output_token ||
! 894: !output_token->length || !output_token->value)
! 895: return rc;
! 896:
! 897: /* No way to allocate a buffer here, because it will be released by
! 898: gss_release_buffer(). The solution is to overwrite the EBCDIC buffer
! 899: with ASCII to return it. */
! 900:
! 901: if(Curl_gss_convert_in_place(minor_status, output_token))
! 902: return GSS_S_FAILURE;
! 903:
! 904: return rc;
! 905: }
! 906:
! 907:
! 908: OM_uint32
! 909: Curl_gss_delete_sec_context_a(OM_uint32 * minor_status,
! 910: gss_ctx_id_t * context_handle,
! 911: gss_buffer_t output_token)
! 912:
! 913: {
! 914: int rc;
! 915:
! 916: rc = gss_delete_sec_context(minor_status, context_handle, output_token);
! 917:
! 918: if(rc != GSS_S_COMPLETE || !output_token ||
! 919: !output_token->length || !output_token->value)
! 920: return rc;
! 921:
! 922: /* No way to allocate a buffer here, because it will be released by
! 923: gss_release_buffer(). The solution is to overwrite the EBCDIC buffer
! 924: with ASCII to return it. */
! 925:
! 926: if(Curl_gss_convert_in_place(minor_status, output_token))
! 927: return GSS_S_FAILURE;
! 928:
! 929: return rc;
! 930: }
! 931:
! 932: #endif /* HAVE_GSSAPI */
! 933:
! 934:
! 935: #ifndef CURL_DISABLE_LDAP
! 936:
! 937: /* ASCII wrappers for the LDAP procedures. */
! 938:
! 939: void *
! 940: Curl_ldap_init_a(char * host, int port)
! 941:
! 942: {
! 943: unsigned int i;
! 944: char * ehost;
! 945: void * result;
! 946:
! 947: if(!host)
! 948: return (void *) ldap_init(host, port);
! 949:
! 950: i = strlen(host);
! 951:
! 952: ehost = malloc(i + 1);
! 953: if(!ehost)
! 954: return (void *) NULL;
! 955:
! 956: QadrtConvertA2E(ehost, host, i, i);
! 957: ehost[i] = '\0';
! 958: result = (void *) ldap_init(ehost, port);
! 959: free(ehost);
! 960: return result;
! 961: }
! 962:
! 963:
! 964: int
! 965: Curl_ldap_simple_bind_s_a(void * ld, char * dn, char * passwd)
! 966:
! 967: {
! 968: int i;
! 969: char * edn;
! 970: char * epasswd;
! 971:
! 972: edn = (char *) NULL;
! 973: epasswd = (char *) NULL;
! 974:
! 975: if(dn) {
! 976: i = strlen(dn);
! 977:
! 978: edn = malloc(i + 1);
! 979: if(!edn)
! 980: return LDAP_NO_MEMORY;
! 981:
! 982: QadrtConvertA2E(edn, dn, i, i);
! 983: edn[i] = '\0';
! 984: }
! 985:
! 986: if(passwd) {
! 987: i = strlen(passwd);
! 988:
! 989: epasswd = malloc(i + 1);
! 990: if(!epasswd) {
! 991: free(edn);
! 992: return LDAP_NO_MEMORY;
! 993: }
! 994:
! 995: QadrtConvertA2E(epasswd, passwd, i, i);
! 996: epasswd[i] = '\0';
! 997: }
! 998:
! 999: i = ldap_simple_bind_s(ld, edn, epasswd);
! 1000: free(epasswd);
! 1001: free(edn);
! 1002: return i;
! 1003: }
! 1004:
! 1005:
! 1006: int
! 1007: Curl_ldap_search_s_a(void * ld, char * base, int scope, char * filter,
! 1008: char * * attrs, int attrsonly, LDAPMessage * * res)
! 1009:
! 1010: {
! 1011: int i;
! 1012: int j;
! 1013: char * ebase;
! 1014: char * efilter;
! 1015: char * * eattrs;
! 1016: int status;
! 1017:
! 1018: ebase = (char *) NULL;
! 1019: efilter = (char *) NULL;
! 1020: eattrs = (char * *) NULL;
! 1021: status = LDAP_SUCCESS;
! 1022:
! 1023: if(base) {
! 1024: i = strlen(base);
! 1025:
! 1026: ebase = malloc(i + 1);
! 1027: if(!ebase)
! 1028: status = LDAP_NO_MEMORY;
! 1029: else {
! 1030: QadrtConvertA2E(ebase, base, i, i);
! 1031: ebase[i] = '\0';
! 1032: }
! 1033: }
! 1034:
! 1035: if(filter && status == LDAP_SUCCESS) {
! 1036: i = strlen(filter);
! 1037:
! 1038: efilter = malloc(i + 1);
! 1039: if(!efilter)
! 1040: status = LDAP_NO_MEMORY;
! 1041: else {
! 1042: QadrtConvertA2E(efilter, filter, i, i);
! 1043: efilter[i] = '\0';
! 1044: }
! 1045: }
! 1046:
! 1047: if(attrs && status == LDAP_SUCCESS) {
! 1048: for(i = 0; attrs[i++];)
! 1049: ;
! 1050:
! 1051: eattrs = calloc(i, sizeof(*eattrs));
! 1052: if(!eattrs)
! 1053: status = LDAP_NO_MEMORY;
! 1054: else {
! 1055: for(j = 0; attrs[j]; j++) {
! 1056: i = strlen(attrs[j]);
! 1057:
! 1058: eattrs[j] = malloc(i + 1);
! 1059: if(!eattrs[j]) {
! 1060: status = LDAP_NO_MEMORY;
! 1061: break;
! 1062: }
! 1063:
! 1064: QadrtConvertA2E(eattrs[j], attrs[j], i, i);
! 1065: eattrs[j][i] = '\0';
! 1066: }
! 1067: }
! 1068: }
! 1069:
! 1070: if(status == LDAP_SUCCESS)
! 1071: status = ldap_search_s(ld, ebase? ebase: "", scope,
! 1072: efilter? efilter: "(objectclass=*)",
! 1073: eattrs, attrsonly, res);
! 1074:
! 1075: if(eattrs) {
! 1076: for(j = 0; eattrs[j]; j++)
! 1077: free(eattrs[j]);
! 1078:
! 1079: free(eattrs);
! 1080: }
! 1081:
! 1082: free(efilter);
! 1083: free(ebase);
! 1084: return status;
! 1085: }
! 1086:
! 1087:
! 1088: struct berval * *
! 1089: Curl_ldap_get_values_len_a(void * ld, LDAPMessage * entry, const char * attr)
! 1090:
! 1091: {
! 1092: char * cp;
! 1093: struct berval * * result;
! 1094:
! 1095: cp = (char *) NULL;
! 1096:
! 1097: if(attr) {
! 1098: int i = strlen(attr);
! 1099:
! 1100: cp = malloc(i + 1);
! 1101: if(!cp) {
! 1102: ldap_set_lderrno(ld, LDAP_NO_MEMORY, NULL,
! 1103: ldap_err2string(LDAP_NO_MEMORY));
! 1104: return (struct berval * *) NULL;
! 1105: }
! 1106:
! 1107: QadrtConvertA2E(cp, attr, i, i);
! 1108: cp[i] = '\0';
! 1109: }
! 1110:
! 1111: result = ldap_get_values_len(ld, entry, cp);
! 1112: free(cp);
! 1113:
! 1114: /* Result data are binary in nature, so they haven't been
! 1115: converted to EBCDIC. Therefore do not convert. */
! 1116:
! 1117: return result;
! 1118: }
! 1119:
! 1120:
! 1121: char *
! 1122: Curl_ldap_err2string_a(int error)
! 1123:
! 1124: {
! 1125: return set_thread_string(LK_LDAP_ERROR, ldap_err2string(error));
! 1126: }
! 1127:
! 1128:
! 1129: char *
! 1130: Curl_ldap_get_dn_a(void * ld, LDAPMessage * entry)
! 1131:
! 1132: {
! 1133: int i;
! 1134: char * cp;
! 1135: char * cp2;
! 1136:
! 1137: cp = ldap_get_dn(ld, entry);
! 1138:
! 1139: if(!cp)
! 1140: return cp;
! 1141:
! 1142: i = strlen(cp);
! 1143:
! 1144: cp2 = malloc(i + 1);
! 1145: if(!cp2)
! 1146: return cp2;
! 1147:
! 1148: QadrtConvertE2A(cp2, cp, i, i);
! 1149: cp2[i] = '\0';
! 1150:
! 1151: /* No way to allocate a buffer here, because it will be released by
! 1152: ldap_memfree() and ldap_memalloc() does not exist. The solution is to
! 1153: overwrite the EBCDIC buffer with ASCII to return it. */
! 1154:
! 1155: strcpy(cp, cp2);
! 1156: free(cp2);
! 1157: return cp;
! 1158: }
! 1159:
! 1160:
! 1161: char *
! 1162: Curl_ldap_first_attribute_a(void * ld,
! 1163: LDAPMessage * entry, BerElement * * berptr)
! 1164:
! 1165: {
! 1166: int i;
! 1167: char * cp;
! 1168: char * cp2;
! 1169:
! 1170: cp = ldap_first_attribute(ld, entry, berptr);
! 1171:
! 1172: if(!cp)
! 1173: return cp;
! 1174:
! 1175: i = strlen(cp);
! 1176:
! 1177: cp2 = malloc(i + 1);
! 1178: if(!cp2)
! 1179: return cp2;
! 1180:
! 1181: QadrtConvertE2A(cp2, cp, i, i);
! 1182: cp2[i] = '\0';
! 1183:
! 1184: /* No way to allocate a buffer here, because it will be released by
! 1185: ldap_memfree() and ldap_memalloc() does not exist. The solution is to
! 1186: overwrite the EBCDIC buffer with ASCII to return it. */
! 1187:
! 1188: strcpy(cp, cp2);
! 1189: free(cp2);
! 1190: return cp;
! 1191: }
! 1192:
! 1193:
! 1194: char *
! 1195: Curl_ldap_next_attribute_a(void * ld,
! 1196: LDAPMessage * entry, BerElement * berptr)
! 1197:
! 1198: {
! 1199: int i;
! 1200: char * cp;
! 1201: char * cp2;
! 1202:
! 1203: cp = ldap_next_attribute(ld, entry, berptr);
! 1204:
! 1205: if(!cp)
! 1206: return cp;
! 1207:
! 1208: i = strlen(cp);
! 1209:
! 1210: cp2 = malloc(i + 1);
! 1211: if(!cp2)
! 1212: return cp2;
! 1213:
! 1214: QadrtConvertE2A(cp2, cp, i, i);
! 1215: cp2[i] = '\0';
! 1216:
! 1217: /* No way to allocate a buffer here, because it will be released by
! 1218: ldap_memfree() and ldap_memalloc() does not exist. The solution is to
! 1219: overwrite the EBCDIC buffer with ASCII to return it. */
! 1220:
! 1221: strcpy(cp, cp2);
! 1222: free(cp2);
! 1223: return cp;
! 1224: }
! 1225:
! 1226: #endif /* CURL_DISABLE_LDAP */
! 1227:
! 1228:
! 1229: static int
! 1230: sockaddr2ebcdic(struct sockaddr_storage *dstaddr,
! 1231: const struct sockaddr *srcaddr, int srclen)
! 1232: {
! 1233: const struct sockaddr_un *srcu;
! 1234: struct sockaddr_un *dstu;
! 1235: unsigned int i;
! 1236: unsigned int dstsize;
! 1237:
! 1238: /* Convert a socket address to job CCSID, if needed. */
! 1239:
! 1240: if(!srcaddr || srclen < offsetof(struct sockaddr, sa_family) +
! 1241: sizeof(srcaddr->sa_family) || srclen > sizeof(*dstaddr)) {
! 1242: errno = EINVAL;
! 1243: return -1;
! 1244: }
! 1245:
! 1246: memcpy((char *) dstaddr, (char *) srcaddr, srclen);
! 1247:
! 1248: switch (srcaddr->sa_family) {
! 1249:
! 1250: case AF_UNIX:
! 1251: srcu = (const struct sockaddr_un *) srcaddr;
! 1252: dstu = (struct sockaddr_un *) dstaddr;
! 1253: dstsize = sizeof(*dstaddr) - offsetof(struct sockaddr_un, sun_path);
! 1254: srclen -= offsetof(struct sockaddr_un, sun_path);
! 1255: i = QadrtConvertA2E(dstu->sun_path, srcu->sun_path, dstsize - 1, srclen);
! 1256: dstu->sun_path[i] = '\0';
! 1257: srclen = i + offsetof(struct sockaddr_un, sun_path);
! 1258: }
! 1259:
! 1260: return srclen;
! 1261: }
! 1262:
! 1263:
! 1264: static int
! 1265: sockaddr2ascii(struct sockaddr *dstaddr, int dstlen,
! 1266: const struct sockaddr_storage *srcaddr, int srclen)
! 1267: {
! 1268: const struct sockaddr_un *srcu;
! 1269: struct sockaddr_un *dstu;
! 1270: unsigned int dstsize;
! 1271:
! 1272: /* Convert a socket address to ASCII, if needed. */
! 1273:
! 1274: if(!srclen)
! 1275: return 0;
! 1276: if(srclen > dstlen)
! 1277: srclen = dstlen;
! 1278: if(!srcaddr || srclen < 0) {
! 1279: errno = EINVAL;
! 1280: return -1;
! 1281: }
! 1282:
! 1283: memcpy((char *) dstaddr, (char *) srcaddr, srclen);
! 1284:
! 1285: if(srclen >= offsetof(struct sockaddr_storage, ss_family) +
! 1286: sizeof(srcaddr->ss_family)) {
! 1287: switch (srcaddr->ss_family) {
! 1288:
! 1289: case AF_UNIX:
! 1290: srcu = (const struct sockaddr_un *) srcaddr;
! 1291: dstu = (struct sockaddr_un *) dstaddr;
! 1292: dstsize = dstlen - offsetof(struct sockaddr_un, sun_path);
! 1293: srclen -= offsetof(struct sockaddr_un, sun_path);
! 1294: if(dstsize > 0 && srclen > 0) {
! 1295: srclen = QadrtConvertE2A(dstu->sun_path, srcu->sun_path,
! 1296: dstsize - 1, srclen);
! 1297: dstu->sun_path[srclen] = '\0';
! 1298: }
! 1299: srclen += offsetof(struct sockaddr_un, sun_path);
! 1300: }
! 1301: }
! 1302:
! 1303: return srclen;
! 1304: }
! 1305:
! 1306:
! 1307: int
! 1308: Curl_os400_connect(int sd, struct sockaddr * destaddr, int addrlen)
! 1309: {
! 1310: int i;
! 1311: struct sockaddr_storage laddr;
! 1312:
! 1313: i = sockaddr2ebcdic(&laddr, destaddr, addrlen);
! 1314:
! 1315: if(i < 0)
! 1316: return -1;
! 1317:
! 1318: return connect(sd, (struct sockaddr *) &laddr, i);
! 1319: }
! 1320:
! 1321:
! 1322: int
! 1323: Curl_os400_bind(int sd, struct sockaddr * localaddr, int addrlen)
! 1324: {
! 1325: int i;
! 1326: struct sockaddr_storage laddr;
! 1327:
! 1328: i = sockaddr2ebcdic(&laddr, localaddr, addrlen);
! 1329:
! 1330: if(i < 0)
! 1331: return -1;
! 1332:
! 1333: return bind(sd, (struct sockaddr *) &laddr, i);
! 1334: }
! 1335:
! 1336:
! 1337: int
! 1338: Curl_os400_sendto(int sd, char * buffer, int buflen, int flags,
! 1339: struct sockaddr * dstaddr, int addrlen)
! 1340: {
! 1341: int i;
! 1342: struct sockaddr_storage laddr;
! 1343:
! 1344: i = sockaddr2ebcdic(&laddr, dstaddr, addrlen);
! 1345:
! 1346: if(i < 0)
! 1347: return -1;
! 1348:
! 1349: return sendto(sd, buffer, buflen, flags, (struct sockaddr *) &laddr, i);
! 1350: }
! 1351:
! 1352:
! 1353: int
! 1354: Curl_os400_recvfrom(int sd, char * buffer, int buflen, int flags,
! 1355: struct sockaddr * fromaddr, int * addrlen)
! 1356: {
! 1357: int rcvlen;
! 1358: struct sockaddr_storage laddr;
! 1359: int laddrlen = sizeof(laddr);
! 1360:
! 1361: if(!fromaddr || !addrlen || *addrlen <= 0)
! 1362: return recvfrom(sd, buffer, buflen, flags, fromaddr, addrlen);
! 1363:
! 1364: laddr.ss_family = AF_UNSPEC; /* To detect if unused. */
! 1365: rcvlen = recvfrom(sd, buffer, buflen, flags,
! 1366: (struct sockaddr *) &laddr, &laddrlen);
! 1367:
! 1368: if(rcvlen < 0)
! 1369: return rcvlen;
! 1370:
! 1371: if(laddr.ss_family == AF_UNSPEC)
! 1372: laddrlen = 0;
! 1373: else {
! 1374: laddrlen = sockaddr2ascii(fromaddr, *addrlen, &laddr, laddrlen);
! 1375: if(laddrlen < 0)
! 1376: return laddrlen;
! 1377: }
! 1378: *addrlen = laddrlen;
! 1379: return rcvlen;
! 1380: }
! 1381:
! 1382:
! 1383: int
! 1384: Curl_os400_getpeername(int sd, struct sockaddr *addr, int *addrlen)
! 1385: {
! 1386: struct sockaddr_storage laddr;
! 1387: int laddrlen = sizeof(laddr);
! 1388: int retcode = getpeername(sd, (struct sockaddr *) &laddr, &laddrlen);
! 1389:
! 1390: if(!retcode) {
! 1391: laddrlen = sockaddr2ascii(addr, *addrlen, &laddr, laddrlen);
! 1392: if(laddrlen < 0)
! 1393: return laddrlen;
! 1394: *addrlen = laddrlen;
! 1395: }
! 1396:
! 1397: return retcode;
! 1398: }
! 1399:
! 1400:
! 1401: int
! 1402: Curl_os400_getsockname(int sd, struct sockaddr *addr, int *addrlen)
! 1403: {
! 1404: struct sockaddr_storage laddr;
! 1405: int laddrlen = sizeof(laddr);
! 1406: int retcode = getsockname(sd, (struct sockaddr *) &laddr, &laddrlen);
! 1407:
! 1408: if(!retcode) {
! 1409: laddrlen = sockaddr2ascii(addr, *addrlen, &laddr, laddrlen);
! 1410: if(laddrlen < 0)
! 1411: return laddrlen;
! 1412: *addrlen = laddrlen;
! 1413: }
! 1414:
! 1415: return retcode;
! 1416: }
! 1417:
! 1418:
! 1419: #ifdef HAVE_LIBZ
! 1420: const char *
! 1421: Curl_os400_zlibVersion(void)
! 1422:
! 1423: {
! 1424: return set_thread_string(LK_ZLIB_VERSION, zlibVersion());
! 1425: }
! 1426:
! 1427:
! 1428: int
! 1429: Curl_os400_inflateInit_(z_streamp strm, const char * version, int stream_size)
! 1430:
! 1431: {
! 1432: z_const char * msgb4 = strm->msg;
! 1433: int ret;
! 1434:
! 1435: ret = inflateInit(strm);
! 1436:
! 1437: if(strm->msg != msgb4)
! 1438: strm->msg = set_thread_string(LK_ZLIB_MSG, strm->msg);
! 1439:
! 1440: return ret;
! 1441: }
! 1442:
! 1443:
! 1444: int
! 1445: Curl_os400_inflateInit2_(z_streamp strm, int windowBits,
! 1446: const char * version, int stream_size)
! 1447:
! 1448: {
! 1449: z_const char * msgb4 = strm->msg;
! 1450: int ret;
! 1451:
! 1452: ret = inflateInit2(strm, windowBits);
! 1453:
! 1454: if(strm->msg != msgb4)
! 1455: strm->msg = set_thread_string(LK_ZLIB_MSG, strm->msg);
! 1456:
! 1457: return ret;
! 1458: }
! 1459:
! 1460:
! 1461: int
! 1462: Curl_os400_inflate(z_streamp strm, int flush)
! 1463:
! 1464: {
! 1465: z_const char * msgb4 = strm->msg;
! 1466: int ret;
! 1467:
! 1468: ret = inflate(strm, flush);
! 1469:
! 1470: if(strm->msg != msgb4)
! 1471: strm->msg = set_thread_string(LK_ZLIB_MSG, strm->msg);
! 1472:
! 1473: return ret;
! 1474: }
! 1475:
! 1476:
! 1477: int
! 1478: Curl_os400_inflateEnd(z_streamp strm)
! 1479:
! 1480: {
! 1481: z_const char * msgb4 = strm->msg;
! 1482: int ret;
! 1483:
! 1484: ret = inflateEnd(strm);
! 1485:
! 1486: if(strm->msg != msgb4)
! 1487: strm->msg = set_thread_string(LK_ZLIB_MSG, strm->msg);
! 1488:
! 1489: return ret;
! 1490: }
! 1491:
! 1492: #endif
FreeBSD-CVSweb <freebsd-cvsweb@FreeBSD.org>
![[BACK]](/icons/cvsweb/back.gif){kind=icon}
Return to os400sys.c CVS log ![[TXT]](/icons/cvsweb/text.gif){kind=icon}
![[DIR]](/icons/cvsweb/dir.gif){kind=icon}
Up to [ELWIX - Embedded LightWeight unIX -] / embedaddon / curl / packages / OS400