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