| OLD | NEW |
|---|
| (Empty) | |
| 1 /* |
| 2 * nanoftp.c: basic FTP client support |
| 3 * |
| 4 * Reference: RFC 959 |
| 5 */ |
| 6 |
| 7 #ifdef TESTING |
| 8 #define STANDALONE |
| 9 #define HAVE_STDLIB_H |
| 10 #define HAVE_UNISTD_H |
| 11 #define HAVE_SYS_SOCKET_H |
| 12 #define HAVE_NETINET_IN_H |
| 13 #define HAVE_NETDB_H |
| 14 #define HAVE_SYS_TIME_H |
| 15 #else /* TESTING */ |
| 16 #define NEED_SOCKETS |
| 17 #endif /* TESTING */ |
| 18 |
| 19 #define IN_LIBXML |
| 20 #include "libxml.h" |
| 21 |
| 22 #ifdef LIBXML_FTP_ENABLED |
| 23 #include <string.h> |
| 24 |
| 25 #ifdef HAVE_STDLIB_H |
| 26 #include <stdlib.h> |
| 27 #endif |
| 28 #ifdef HAVE_UNISTD_H |
| 29 #include <unistd.h> |
| 30 #endif |
| 31 #ifdef HAVE_SYS_SOCKET_H |
| 32 #include <sys/socket.h> |
| 33 #endif |
| 34 #ifdef HAVE_NETINET_IN_H |
| 35 #include <netinet/in.h> |
| 36 #endif |
| 37 #ifdef HAVE_ARPA_INET_H |
| 38 #include <arpa/inet.h> |
| 39 #endif |
| 40 #ifdef HAVE_NETDB_H |
| 41 #include <netdb.h> |
| 42 #endif |
| 43 #ifdef HAVE_FCNTL_H |
| 44 #include <fcntl.h> |
| 45 #endif |
| 46 #ifdef HAVE_ERRNO_H |
| 47 #include <errno.h> |
| 48 #endif |
| 49 #ifdef HAVE_SYS_TIME_H |
| 50 #include <sys/time.h> |
| 51 #endif |
| 52 #ifdef HAVE_SYS_SELECT_H |
| 53 #include <sys/select.h> |
| 54 #endif |
| 55 #ifdef HAVE_SYS_SOCKET_H |
| 56 #include <sys/socket.h> |
| 57 #endif |
| 58 #ifdef HAVE_SYS_TYPES_H |
| 59 #include <sys/types.h> |
| 60 #endif |
| 61 #ifdef HAVE_STRINGS_H |
| 62 #include <strings.h> |
| 63 #endif |
| 64 |
| 65 #include <libxml/xmlmemory.h> |
| 66 #include <libxml/parser.h> |
| 67 #include <libxml/xmlerror.h> |
| 68 #include <libxml/uri.h> |
| 69 #include <libxml/nanoftp.h> |
| 70 #include <libxml/globals.h> |
| 71 |
| 72 /* #define DEBUG_FTP 1 */ |
| 73 #ifdef STANDALONE |
| 74 #ifndef DEBUG_FTP |
| 75 #define DEBUG_FTP 1 |
| 76 #endif |
| 77 #endif |
| 78 |
| 79 |
| 80 #if defined(__MINGW32__) || defined(_WIN32_WCE) |
| 81 #ifndef _WINSOCKAPI_ |
| 82 #define _WINSOCKAPI_ |
| 83 #endif |
| 84 #include <wsockcompat.h> |
| 85 #include <winsock2.h> |
| 86 #undef XML_SOCKLEN_T |
| 87 #define XML_SOCKLEN_T unsigned int |
| 88 #endif |
| 89 |
| 90 /** |
| 91 * A couple portability macros |
| 92 */ |
| 93 #ifndef _WINSOCKAPI_ |
| 94 #if !defined(__BEOS__) || defined(__HAIKU__) |
| 95 #define closesocket(s) close(s) |
| 96 #endif |
| 97 #endif |
| 98 |
| 99 #ifdef __BEOS__ |
| 100 #ifndef PF_INET |
| 101 #define PF_INET AF_INET |
| 102 #endif |
| 103 #endif |
| 104 |
| 105 #ifdef _AIX |
| 106 #ifdef HAVE_BROKEN_SS_FAMILY |
| 107 #define ss_family __ss_family |
| 108 #endif |
| 109 #endif |
| 110 |
| 111 #ifndef XML_SOCKLEN_T |
| 112 #define XML_SOCKLEN_T unsigned int |
| 113 #endif |
| 114 |
| 115 #define FTP_COMMAND_OK 200 |
| 116 #define FTP_SYNTAX_ERROR 500 |
| 117 #define FTP_GET_PASSWD 331 |
| 118 #define FTP_BUF_SIZE 1024 |
| 119 |
| 120 #define XML_NANO_MAX_URLBUF 4096 |
| 121 |
| 122 typedef struct xmlNanoFTPCtxt { |
| 123 char *protocol; /* the protocol name */ |
| 124 char *hostname; /* the host name */ |
| 125 int port; /* the port */ |
| 126 char *path; /* the path within the URL */ |
| 127 char *user; /* user string */ |
| 128 char *passwd; /* passwd string */ |
| 129 #ifdef SUPPORT_IP6 |
| 130 struct sockaddr_storage ftpAddr; /* this is large enough to hold IPv6 addres
s*/ |
| 131 #else |
| 132 struct sockaddr_in ftpAddr; /* the socket address struct */ |
| 133 #endif |
| 134 int passive; /* currently we support only passive !!! */ |
| 135 SOCKET controlFd; /* the file descriptor for the control socket */ |
| 136 SOCKET dataFd; /* the file descriptor for the data socket */ |
| 137 int state; /* WRITE / READ / CLOSED */ |
| 138 int returnValue; /* the protocol return value */ |
| 139 /* buffer for data received from the control connection */ |
| 140 char controlBuf[FTP_BUF_SIZE + 1]; |
| 141 int controlBufIndex; |
| 142 int controlBufUsed; |
| 143 int controlBufAnswer; |
| 144 } xmlNanoFTPCtxt, *xmlNanoFTPCtxtPtr; |
| 145 |
| 146 static int initialized = 0; |
| 147 static char *proxy = NULL; /* the proxy name if any */ |
| 148 static int proxyPort = 0; /* the proxy port if any */ |
| 149 static char *proxyUser = NULL; /* user for proxy authentication */ |
| 150 static char *proxyPasswd = NULL;/* passwd for proxy authentication */ |
| 151 static int proxyType = 0; /* uses TYPE or a@b ? */ |
| 152 |
| 153 #ifdef SUPPORT_IP6 |
| 154 static |
| 155 int have_ipv6(void) { |
| 156 int s; |
| 157 |
| 158 s = socket (AF_INET6, SOCK_STREAM, 0); |
| 159 if (s != -1) { |
| 160 close (s); |
| 161 return (1); |
| 162 } |
| 163 return (0); |
| 164 } |
| 165 #endif |
| 166 |
| 167 /** |
| 168 * xmlFTPErrMemory: |
| 169 * @extra: extra informations |
| 170 * |
| 171 * Handle an out of memory condition |
| 172 */ |
| 173 static void |
| 174 xmlFTPErrMemory(const char *extra) |
| 175 { |
| 176 __xmlSimpleError(XML_FROM_FTP, XML_ERR_NO_MEMORY, NULL, NULL, extra); |
| 177 } |
| 178 |
| 179 /** |
| 180 * xmlNanoFTPInit: |
| 181 * |
| 182 * Initialize the FTP protocol layer. |
| 183 * Currently it just checks for proxy informations, |
| 184 * and get the hostname |
| 185 */ |
| 186 |
| 187 void |
| 188 xmlNanoFTPInit(void) { |
| 189 const char *env; |
| 190 #ifdef _WINSOCKAPI_ |
| 191 WSADATA wsaData; |
| 192 #endif |
| 193 |
| 194 if (initialized) |
| 195 return; |
| 196 |
| 197 #ifdef _WINSOCKAPI_ |
| 198 if (WSAStartup(MAKEWORD(1, 1), &wsaData) != 0) |
| 199 return; |
| 200 #endif |
| 201 |
| 202 proxyPort = 21; |
| 203 env = getenv("no_proxy"); |
| 204 if (env && ((env[0] == '*' ) && (env[1] == 0))) |
| 205 return; |
| 206 env = getenv("ftp_proxy"); |
| 207 if (env != NULL) { |
| 208 xmlNanoFTPScanProxy(env); |
| 209 } else { |
| 210 env = getenv("FTP_PROXY"); |
| 211 if (env != NULL) { |
| 212 xmlNanoFTPScanProxy(env); |
| 213 } |
| 214 } |
| 215 env = getenv("ftp_proxy_user"); |
| 216 if (env != NULL) { |
| 217 proxyUser = xmlMemStrdup(env); |
| 218 } |
| 219 env = getenv("ftp_proxy_password"); |
| 220 if (env != NULL) { |
| 221 proxyPasswd = xmlMemStrdup(env); |
| 222 } |
| 223 initialized = 1; |
| 224 } |
| 225 |
| 226 /** |
| 227 * xmlNanoFTPCleanup: |
| 228 * |
| 229 * Cleanup the FTP protocol layer. This cleanup proxy informations. |
| 230 */ |
| 231 |
| 232 void |
| 233 xmlNanoFTPCleanup(void) { |
| 234 if (proxy != NULL) { |
| 235 xmlFree(proxy); |
| 236 proxy = NULL; |
| 237 } |
| 238 if (proxyUser != NULL) { |
| 239 xmlFree(proxyUser); |
| 240 proxyUser = NULL; |
| 241 } |
| 242 if (proxyPasswd != NULL) { |
| 243 xmlFree(proxyPasswd); |
| 244 proxyPasswd = NULL; |
| 245 } |
| 246 #ifdef _WINSOCKAPI_ |
| 247 if (initialized) |
| 248 WSACleanup(); |
| 249 #endif |
| 250 initialized = 0; |
| 251 } |
| 252 |
| 253 /** |
| 254 * xmlNanoFTPProxy: |
| 255 * @host: the proxy host name |
| 256 * @port: the proxy port |
| 257 * @user: the proxy user name |
| 258 * @passwd: the proxy password |
| 259 * @type: the type of proxy 1 for using SITE, 2 for USER a@b |
| 260 * |
| 261 * Setup the FTP proxy informations. |
| 262 * This can also be done by using ftp_proxy ftp_proxy_user and |
| 263 * ftp_proxy_password environment variables. |
| 264 */ |
| 265 |
| 266 void |
| 267 xmlNanoFTPProxy(const char *host, int port, const char *user, |
| 268 const char *passwd, int type) { |
| 269 if (proxy != NULL) { |
| 270 xmlFree(proxy); |
| 271 proxy = NULL; |
| 272 } |
| 273 if (proxyUser != NULL) { |
| 274 xmlFree(proxyUser); |
| 275 proxyUser = NULL; |
| 276 } |
| 277 if (proxyPasswd != NULL) { |
| 278 xmlFree(proxyPasswd); |
| 279 proxyPasswd = NULL; |
| 280 } |
| 281 if (host) |
| 282 proxy = xmlMemStrdup(host); |
| 283 if (user) |
| 284 proxyUser = xmlMemStrdup(user); |
| 285 if (passwd) |
| 286 proxyPasswd = xmlMemStrdup(passwd); |
| 287 proxyPort = port; |
| 288 proxyType = type; |
| 289 } |
| 290 |
| 291 /** |
| 292 * xmlNanoFTPScanURL: |
| 293 * @ctx: an FTP context |
| 294 * @URL: The URL used to initialize the context |
| 295 * |
| 296 * (Re)Initialize an FTP context by parsing the URL and finding |
| 297 * the protocol host port and path it indicates. |
| 298 */ |
| 299 |
| 300 static void |
| 301 xmlNanoFTPScanURL(void *ctx, const char *URL) { |
| 302 xmlNanoFTPCtxtPtr ctxt = (xmlNanoFTPCtxtPtr) ctx; |
| 303 xmlURIPtr uri; |
| 304 |
| 305 /* |
| 306 * Clear any existing data from the context |
| 307 */ |
| 308 if (ctxt->protocol != NULL) { |
| 309 xmlFree(ctxt->protocol); |
| 310 ctxt->protocol = NULL; |
| 311 } |
| 312 if (ctxt->hostname != NULL) { |
| 313 xmlFree(ctxt->hostname); |
| 314 ctxt->hostname = NULL; |
| 315 } |
| 316 if (ctxt->path != NULL) { |
| 317 xmlFree(ctxt->path); |
| 318 ctxt->path = NULL; |
| 319 } |
| 320 if (URL == NULL) return; |
| 321 |
| 322 uri = xmlParseURIRaw(URL, 1); |
| 323 if (uri == NULL) |
| 324 return; |
| 325 |
| 326 if ((uri->scheme == NULL) || (uri->server == NULL)) { |
| 327 xmlFreeURI(uri); |
| 328 return; |
| 329 } |
| 330 |
| 331 ctxt->protocol = xmlMemStrdup(uri->scheme); |
| 332 ctxt->hostname = xmlMemStrdup(uri->server); |
| 333 if (uri->path != NULL) |
| 334 ctxt->path = xmlMemStrdup(uri->path); |
| 335 else |
| 336 ctxt->path = xmlMemStrdup("/"); |
| 337 if (uri->port != 0) |
| 338 ctxt->port = uri->port; |
| 339 |
| 340 if (uri->user != NULL) { |
| 341 char *cptr; |
| 342 if ((cptr=strchr(uri->user, ':')) == NULL) |
| 343 ctxt->user = xmlMemStrdup(uri->user); |
| 344 else { |
| 345 ctxt->user = (char *)xmlStrndup((xmlChar *)uri->user, |
| 346 (cptr - uri->user)); |
| 347 ctxt->passwd = xmlMemStrdup(cptr+1); |
| 348 } |
| 349 } |
| 350 |
| 351 xmlFreeURI(uri); |
| 352 |
| 353 } |
| 354 |
| 355 /** |
| 356 * xmlNanoFTPUpdateURL: |
| 357 * @ctx: an FTP context |
| 358 * @URL: The URL used to update the context |
| 359 * |
| 360 * Update an FTP context by parsing the URL and finding |
| 361 * new path it indicates. If there is an error in the |
| 362 * protocol, hostname, port or other information, the |
| 363 * error is raised. It indicates a new connection has to |
| 364 * be established. |
| 365 * |
| 366 * Returns 0 if Ok, -1 in case of error (other host). |
| 367 */ |
| 368 |
| 369 int |
| 370 xmlNanoFTPUpdateURL(void *ctx, const char *URL) { |
| 371 xmlNanoFTPCtxtPtr ctxt = (xmlNanoFTPCtxtPtr) ctx; |
| 372 xmlURIPtr uri; |
| 373 |
| 374 if (URL == NULL) |
| 375 return(-1); |
| 376 if (ctxt == NULL) |
| 377 return(-1); |
| 378 if (ctxt->protocol == NULL) |
| 379 return(-1); |
| 380 if (ctxt->hostname == NULL) |
| 381 return(-1); |
| 382 |
| 383 uri = xmlParseURIRaw(URL, 1); |
| 384 if (uri == NULL) |
| 385 return(-1); |
| 386 |
| 387 if ((uri->scheme == NULL) || (uri->server == NULL)) { |
| 388 xmlFreeURI(uri); |
| 389 return(-1); |
| 390 } |
| 391 if ((strcmp(ctxt->protocol, uri->scheme)) || |
| 392 (strcmp(ctxt->hostname, uri->server)) || |
| 393 ((uri->port != 0) && (ctxt->port != uri->port))) { |
| 394 xmlFreeURI(uri); |
| 395 return(-1); |
| 396 } |
| 397 |
| 398 if (uri->port != 0) |
| 399 ctxt->port = uri->port; |
| 400 |
| 401 if (ctxt->path != NULL) { |
| 402 xmlFree(ctxt->path); |
| 403 ctxt->path = NULL; |
| 404 } |
| 405 |
| 406 if (uri->path == NULL) |
| 407 ctxt->path = xmlMemStrdup("/"); |
| 408 else |
| 409 ctxt->path = xmlMemStrdup(uri->path); |
| 410 |
| 411 xmlFreeURI(uri); |
| 412 |
| 413 return(0); |
| 414 } |
| 415 |
| 416 /** |
| 417 * xmlNanoFTPScanProxy: |
| 418 * @URL: The proxy URL used to initialize the proxy context |
| 419 * |
| 420 * (Re)Initialize the FTP Proxy context by parsing the URL and finding |
| 421 * the protocol host port it indicates. |
| 422 * Should be like ftp://myproxy/ or ftp://myproxy:3128/ |
| 423 * A NULL URL cleans up proxy informations. |
| 424 */ |
| 425 |
| 426 void |
| 427 xmlNanoFTPScanProxy(const char *URL) { |
| 428 xmlURIPtr uri; |
| 429 |
| 430 if (proxy != NULL) { |
| 431 xmlFree(proxy); |
| 432 proxy = NULL; |
| 433 } |
| 434 proxyPort = 0; |
| 435 |
| 436 #ifdef DEBUG_FTP |
| 437 if (URL == NULL) |
| 438 xmlGenericError(xmlGenericErrorContext, |
| 439 "Removing FTP proxy info\n"); |
| 440 else |
| 441 xmlGenericError(xmlGenericErrorContext, |
| 442 "Using FTP proxy %s\n", URL); |
| 443 #endif |
| 444 if (URL == NULL) return; |
| 445 |
| 446 uri = xmlParseURIRaw(URL, 1); |
| 447 if ((uri == NULL) || (uri->scheme == NULL) || |
| 448 (strcmp(uri->scheme, "ftp")) || (uri->server == NULL)) { |
| 449 __xmlIOErr(XML_FROM_FTP, XML_FTP_URL_SYNTAX, "Syntax Error\n"); |
| 450 if (uri != NULL) |
| 451 xmlFreeURI(uri); |
| 452 return; |
| 453 } |
| 454 |
| 455 proxy = xmlMemStrdup(uri->server); |
| 456 if (uri->port != 0) |
| 457 proxyPort = uri->port; |
| 458 |
| 459 xmlFreeURI(uri); |
| 460 } |
| 461 |
| 462 /** |
| 463 * xmlNanoFTPNewCtxt: |
| 464 * @URL: The URL used to initialize the context |
| 465 * |
| 466 * Allocate and initialize a new FTP context. |
| 467 * |
| 468 * Returns an FTP context or NULL in case of error. |
| 469 */ |
| 470 |
| 471 void* |
| 472 xmlNanoFTPNewCtxt(const char *URL) { |
| 473 xmlNanoFTPCtxtPtr ret; |
| 474 char *unescaped; |
| 475 |
| 476 ret = (xmlNanoFTPCtxtPtr) xmlMalloc(sizeof(xmlNanoFTPCtxt)); |
| 477 if (ret == NULL) { |
| 478 xmlFTPErrMemory("allocating FTP context"); |
| 479 return(NULL); |
| 480 } |
| 481 |
| 482 memset(ret, 0, sizeof(xmlNanoFTPCtxt)); |
| 483 ret->port = 21; |
| 484 ret->passive = 1; |
| 485 ret->returnValue = 0; |
| 486 ret->controlBufIndex = 0; |
| 487 ret->controlBufUsed = 0; |
| 488 ret->controlFd = INVALID_SOCKET; |
| 489 |
| 490 unescaped = xmlURIUnescapeString(URL, 0, NULL); |
| 491 if (unescaped != NULL) { |
| 492 xmlNanoFTPScanURL(ret, unescaped); |
| 493 xmlFree(unescaped); |
| 494 } else if (URL != NULL) |
| 495 xmlNanoFTPScanURL(ret, URL); |
| 496 |
| 497 return(ret); |
| 498 } |
| 499 |
| 500 /** |
| 501 * xmlNanoFTPFreeCtxt: |
| 502 * @ctx: an FTP context |
| 503 * |
| 504 * Frees the context after closing the connection. |
| 505 */ |
| 506 |
| 507 void |
| 508 xmlNanoFTPFreeCtxt(void * ctx) { |
| 509 xmlNanoFTPCtxtPtr ctxt = (xmlNanoFTPCtxtPtr) ctx; |
| 510 if (ctxt == NULL) return; |
| 511 if (ctxt->hostname != NULL) xmlFree(ctxt->hostname); |
| 512 if (ctxt->protocol != NULL) xmlFree(ctxt->protocol); |
| 513 if (ctxt->path != NULL) xmlFree(ctxt->path); |
| 514 ctxt->passive = 1; |
| 515 if (ctxt->controlFd != INVALID_SOCKET) closesocket(ctxt->controlFd); |
| 516 ctxt->controlFd = INVALID_SOCKET; |
| 517 ctxt->controlBufIndex = -1; |
| 518 ctxt->controlBufUsed = -1; |
| 519 xmlFree(ctxt); |
| 520 } |
| 521 |
| 522 /** |
| 523 * xmlNanoFTPParseResponse: |
| 524 * @buf: the buffer containing the response |
| 525 * @len: the buffer length |
| 526 * |
| 527 * Parsing of the server answer, we just extract the code. |
| 528 * |
| 529 * returns 0 for errors |
| 530 * +XXX for last line of response |
| 531 * -XXX for response to be continued |
| 532 */ |
| 533 static int |
| 534 xmlNanoFTPParseResponse(char *buf, int len) { |
| 535 int val = 0; |
| 536 |
| 537 if (len < 3) return(-1); |
| 538 if ((*buf >= '0') && (*buf <= '9')) |
| 539 val = val * 10 + (*buf - '0'); |
| 540 else |
| 541 return(0); |
| 542 buf++; |
| 543 if ((*buf >= '0') && (*buf <= '9')) |
| 544 val = val * 10 + (*buf - '0'); |
| 545 else |
| 546 return(0); |
| 547 buf++; |
| 548 if ((*buf >= '0') && (*buf <= '9')) |
| 549 val = val * 10 + (*buf - '0'); |
| 550 else |
| 551 return(0); |
| 552 buf++; |
| 553 if (*buf == '-') |
| 554 return(-val); |
| 555 return(val); |
| 556 } |
| 557 |
| 558 /** |
| 559 * xmlNanoFTPGetMore: |
| 560 * @ctx: an FTP context |
| 561 * |
| 562 * Read more information from the FTP control connection |
| 563 * Returns the number of bytes read, < 0 indicates an error |
| 564 */ |
| 565 static int |
| 566 xmlNanoFTPGetMore(void *ctx) { |
| 567 xmlNanoFTPCtxtPtr ctxt = (xmlNanoFTPCtxtPtr) ctx; |
| 568 int len; |
| 569 int size; |
| 570 |
| 571 if ((ctxt == NULL) || (ctxt->controlFd == INVALID_SOCKET)) return(-1); |
| 572 |
| 573 if ((ctxt->controlBufIndex < 0) || (ctxt->controlBufIndex > FTP_BUF_SIZE)) { |
| 574 #ifdef DEBUG_FTP |
| 575 xmlGenericError(xmlGenericErrorContext, |
| 576 "xmlNanoFTPGetMore : controlBufIndex = %d\n", |
| 577 ctxt->controlBufIndex); |
| 578 #endif |
| 579 return(-1); |
| 580 } |
| 581 |
| 582 if ((ctxt->controlBufUsed < 0) || (ctxt->controlBufUsed > FTP_BUF_SIZE)) { |
| 583 #ifdef DEBUG_FTP |
| 584 xmlGenericError(xmlGenericErrorContext, |
| 585 "xmlNanoFTPGetMore : controlBufUsed = %d\n", |
| 586 ctxt->controlBufUsed); |
| 587 #endif |
| 588 return(-1); |
| 589 } |
| 590 if (ctxt->controlBufIndex > ctxt->controlBufUsed) { |
| 591 #ifdef DEBUG_FTP |
| 592 xmlGenericError(xmlGenericErrorContext, |
| 593 "xmlNanoFTPGetMore : controlBufIndex > controlBufUsed %d > %d\n"
, |
| 594 ctxt->controlBufIndex, ctxt->controlBufUsed); |
| 595 #endif |
| 596 return(-1); |
| 597 } |
| 598 |
| 599 /* |
| 600 * First pack the control buffer |
| 601 */ |
| 602 if (ctxt->controlBufIndex > 0) { |
| 603 memmove(&ctxt->controlBuf[0], &ctxt->controlBuf[ctxt->controlBufIndex], |
| 604 ctxt->controlBufUsed - ctxt->controlBufIndex); |
| 605 ctxt->controlBufUsed -= ctxt->controlBufIndex; |
| 606 ctxt->controlBufIndex = 0; |
| 607 } |
| 608 size = FTP_BUF_SIZE - ctxt->controlBufUsed; |
| 609 if (size == 0) { |
| 610 #ifdef DEBUG_FTP |
| 611 xmlGenericError(xmlGenericErrorContext, |
| 612 "xmlNanoFTPGetMore : buffer full %d \n", ctxt->controlBufUsed); |
| 613 #endif |
| 614 return(0); |
| 615 } |
| 616 |
| 617 /* |
| 618 * Read the amount left on the control connection |
| 619 */ |
| 620 if ((len = recv(ctxt->controlFd, &ctxt->controlBuf[ctxt->controlBufIndex], |
| 621 size, 0)) < 0) { |
| 622 __xmlIOErr(XML_FROM_FTP, 0, "recv failed"); |
| 623 closesocket(ctxt->controlFd); ctxt->controlFd = INVALID_SOCKET; |
| 624 ctxt->controlFd = INVALID_SOCKET; |
| 625 return(-1); |
| 626 } |
| 627 #ifdef DEBUG_FTP |
| 628 xmlGenericError(xmlGenericErrorContext, |
| 629 "xmlNanoFTPGetMore : read %d [%d - %d]\n", len, |
| 630 ctxt->controlBufUsed, ctxt->controlBufUsed + len); |
| 631 #endif |
| 632 ctxt->controlBufUsed += len; |
| 633 ctxt->controlBuf[ctxt->controlBufUsed] = 0; |
| 634 |
| 635 return(len); |
| 636 } |
| 637 |
| 638 /** |
| 639 * xmlNanoFTPReadResponse: |
| 640 * @ctx: an FTP context |
| 641 * |
| 642 * Read the response from the FTP server after a command. |
| 643 * Returns the code number |
| 644 */ |
| 645 static int |
| 646 xmlNanoFTPReadResponse(void *ctx) { |
| 647 xmlNanoFTPCtxtPtr ctxt = (xmlNanoFTPCtxtPtr) ctx; |
| 648 char *ptr, *end; |
| 649 int len; |
| 650 int res = -1, cur = -1; |
| 651 |
| 652 if ((ctxt == NULL) || (ctxt->controlFd == INVALID_SOCKET)) return(-1); |
| 653 |
| 654 get_more: |
| 655 /* |
| 656 * Assumes everything up to controlBuf[controlBufIndex] has been read |
| 657 * and analyzed. |
| 658 */ |
| 659 len = xmlNanoFTPGetMore(ctx); |
| 660 if (len < 0) { |
| 661 return(-1); |
| 662 } |
| 663 if ((ctxt->controlBufUsed == 0) && (len == 0)) { |
| 664 return(-1); |
| 665 } |
| 666 ptr = &ctxt->controlBuf[ctxt->controlBufIndex]; |
| 667 end = &ctxt->controlBuf[ctxt->controlBufUsed]; |
| 668 |
| 669 #ifdef DEBUG_FTP |
| 670 xmlGenericError(xmlGenericErrorContext, |
| 671 "\n<<<\n%s\n--\n", ptr); |
| 672 #endif |
| 673 while (ptr < end) { |
| 674 cur = xmlNanoFTPParseResponse(ptr, end - ptr); |
| 675 if (cur > 0) { |
| 676 /* |
| 677 * Successfully scanned the control code, scratch |
| 678 * till the end of the line, but keep the index to be |
| 679 * able to analyze the result if needed. |
| 680 */ |
| 681 res = cur; |
| 682 ptr += 3; |
| 683 ctxt->controlBufAnswer = ptr - ctxt->controlBuf; |
| 684 while ((ptr < end) && (*ptr != '\n')) ptr++; |
| 685 if (*ptr == '\n') ptr++; |
| 686 if (*ptr == '\r') ptr++; |
| 687 break; |
| 688 } |
| 689 while ((ptr < end) && (*ptr != '\n')) ptr++; |
| 690 if (ptr >= end) { |
| 691 ctxt->controlBufIndex = ctxt->controlBufUsed; |
| 692 goto get_more; |
| 693 } |
| 694 if (*ptr != '\r') ptr++; |
| 695 } |
| 696 |
| 697 if (res < 0) goto get_more; |
| 698 ctxt->controlBufIndex = ptr - ctxt->controlBuf; |
| 699 #ifdef DEBUG_FTP |
| 700 ptr = &ctxt->controlBuf[ctxt->controlBufIndex]; |
| 701 xmlGenericError(xmlGenericErrorContext, "\n---\n%s\n--\n", ptr); |
| 702 #endif |
| 703 |
| 704 #ifdef DEBUG_FTP |
| 705 xmlGenericError(xmlGenericErrorContext, "Got %d\n", res); |
| 706 #endif |
| 707 return(res / 100); |
| 708 } |
| 709 |
| 710 /** |
| 711 * xmlNanoFTPGetResponse: |
| 712 * @ctx: an FTP context |
| 713 * |
| 714 * Get the response from the FTP server after a command. |
| 715 * Returns the code number |
| 716 */ |
| 717 |
| 718 int |
| 719 xmlNanoFTPGetResponse(void *ctx) { |
| 720 int res; |
| 721 |
| 722 res = xmlNanoFTPReadResponse(ctx); |
| 723 |
| 724 return(res); |
| 725 } |
| 726 |
| 727 /** |
| 728 * xmlNanoFTPCheckResponse: |
| 729 * @ctx: an FTP context |
| 730 * |
| 731 * Check if there is a response from the FTP server after a command. |
| 732 * Returns the code number, or 0 |
| 733 */ |
| 734 |
| 735 int |
| 736 xmlNanoFTPCheckResponse(void *ctx) { |
| 737 xmlNanoFTPCtxtPtr ctxt = (xmlNanoFTPCtxtPtr) ctx; |
| 738 fd_set rfd; |
| 739 struct timeval tv; |
| 740 |
| 741 if ((ctxt == NULL) || (ctxt->controlFd == INVALID_SOCKET)) return(-1); |
| 742 tv.tv_sec = 0; |
| 743 tv.tv_usec = 0; |
| 744 FD_ZERO(&rfd); |
| 745 FD_SET(ctxt->controlFd, &rfd); |
| 746 switch(select(ctxt->controlFd + 1, &rfd, NULL, NULL, &tv)) { |
| 747 case 0: |
| 748 return(0); |
| 749 case -1: |
| 750 __xmlIOErr(XML_FROM_FTP, 0, "select"); |
| 751 return(-1); |
| 752 |
| 753 } |
| 754 |
| 755 return(xmlNanoFTPReadResponse(ctx)); |
| 756 } |
| 757 |
| 758 /** |
| 759 * Send the user authentication |
| 760 */ |
| 761 |
| 762 static int |
| 763 xmlNanoFTPSendUser(void *ctx) { |
| 764 xmlNanoFTPCtxtPtr ctxt = (xmlNanoFTPCtxtPtr) ctx; |
| 765 char buf[200]; |
| 766 int len; |
| 767 int res; |
| 768 |
| 769 if (ctxt->user == NULL) |
| 770 snprintf(buf, sizeof(buf), "USER anonymous\r\n"); |
| 771 else |
| 772 snprintf(buf, sizeof(buf), "USER %s\r\n", ctxt->user); |
| 773 buf[sizeof(buf) - 1] = 0; |
| 774 len = strlen(buf); |
| 775 #ifdef DEBUG_FTP |
| 776 xmlGenericError(xmlGenericErrorContext, "%s", buf); |
| 777 #endif |
| 778 res = send(ctxt->controlFd, SEND_ARG2_CAST buf, len, 0); |
| 779 if (res < 0) { |
| 780 __xmlIOErr(XML_FROM_FTP, 0, "send failed"); |
| 781 return(res); |
| 782 } |
| 783 return(0); |
| 784 } |
| 785 |
| 786 /** |
| 787 * Send the password authentication |
| 788 */ |
| 789 |
| 790 static int |
| 791 xmlNanoFTPSendPasswd(void *ctx) { |
| 792 xmlNanoFTPCtxtPtr ctxt = (xmlNanoFTPCtxtPtr) ctx; |
| 793 char buf[200]; |
| 794 int len; |
| 795 int res; |
| 796 |
| 797 if (ctxt->passwd == NULL) |
| 798 snprintf(buf, sizeof(buf), "PASS anonymous@\r\n"); |
| 799 else |
| 800 snprintf(buf, sizeof(buf), "PASS %s\r\n", ctxt->passwd); |
| 801 buf[sizeof(buf) - 1] = 0; |
| 802 len = strlen(buf); |
| 803 #ifdef DEBUG_FTP |
| 804 xmlGenericError(xmlGenericErrorContext, "%s", buf); |
| 805 #endif |
| 806 res = send(ctxt->controlFd, SEND_ARG2_CAST buf, len, 0); |
| 807 if (res < 0) { |
| 808 __xmlIOErr(XML_FROM_FTP, 0, "send failed"); |
| 809 return(res); |
| 810 } |
| 811 return(0); |
| 812 } |
| 813 |
| 814 /** |
| 815 * xmlNanoFTPQuit: |
| 816 * @ctx: an FTP context |
| 817 * |
| 818 * Send a QUIT command to the server |
| 819 * |
| 820 * Returns -1 in case of error, 0 otherwise |
| 821 */ |
| 822 |
| 823 |
| 824 int |
| 825 xmlNanoFTPQuit(void *ctx) { |
| 826 xmlNanoFTPCtxtPtr ctxt = (xmlNanoFTPCtxtPtr) ctx; |
| 827 char buf[200]; |
| 828 int len, res; |
| 829 |
| 830 if ((ctxt == NULL) || (ctxt->controlFd == INVALID_SOCKET)) return(-1); |
| 831 |
| 832 snprintf(buf, sizeof(buf), "QUIT\r\n"); |
| 833 len = strlen(buf); |
| 834 #ifdef DEBUG_FTP |
| 835 xmlGenericError(xmlGenericErrorContext, "%s", buf); /* Just to be consistent
, even though we know it can't have a % in it */ |
| 836 #endif |
| 837 res = send(ctxt->controlFd, SEND_ARG2_CAST buf, len, 0); |
| 838 if (res < 0) { |
| 839 __xmlIOErr(XML_FROM_FTP, 0, "send failed"); |
| 840 return(res); |
| 841 } |
| 842 return(0); |
| 843 } |
| 844 |
| 845 /** |
| 846 * xmlNanoFTPConnect: |
| 847 * @ctx: an FTP context |
| 848 * |
| 849 * Tries to open a control connection |
| 850 * |
| 851 * Returns -1 in case of error, 0 otherwise |
| 852 */ |
| 853 |
| 854 int |
| 855 xmlNanoFTPConnect(void *ctx) { |
| 856 xmlNanoFTPCtxtPtr ctxt = (xmlNanoFTPCtxtPtr) ctx; |
| 857 struct hostent *hp; |
| 858 int port; |
| 859 int res; |
| 860 int addrlen = sizeof (struct sockaddr_in); |
| 861 |
| 862 if (ctxt == NULL) |
| 863 return(-1); |
| 864 if (ctxt->hostname == NULL) |
| 865 return(-1); |
| 866 |
| 867 /* |
| 868 * do the blocking DNS query. |
| 869 */ |
| 870 if (proxy) { |
| 871 port = proxyPort; |
| 872 } else { |
| 873 port = ctxt->port; |
| 874 } |
| 875 if (port == 0) |
| 876 port = 21; |
| 877 |
| 878 memset (&ctxt->ftpAddr, 0, sizeof(ctxt->ftpAddr)); |
| 879 |
| 880 #ifdef SUPPORT_IP6 |
| 881 if (have_ipv6 ()) { |
| 882 struct addrinfo hints, *tmp, *result; |
| 883 |
| 884 result = NULL; |
| 885 memset (&hints, 0, sizeof(hints)); |
| 886 hints.ai_socktype = SOCK_STREAM; |
| 887 |
| 888 if (proxy) { |
| 889 if (getaddrinfo (proxy, NULL, &hints, &result) != 0) { |
| 890 __xmlIOErr(XML_FROM_FTP, 0, "getaddrinfo failed"); |
| 891 return (-1); |
| 892 } |
| 893 } |
| 894 else |
| 895 if (getaddrinfo (ctxt->hostname, NULL, &hints, &result) != 0) { |
| 896 __xmlIOErr(XML_FROM_FTP, 0, "getaddrinfo failed"); |
| 897 return (-1); |
| 898 } |
| 899 |
| 900 for (tmp = result; tmp; tmp = tmp->ai_next) |
| 901 if (tmp->ai_family == AF_INET || tmp->ai_family == AF_INET6) |
| 902 break; |
| 903 |
| 904 if (!tmp) { |
| 905 if (result) |
| 906 freeaddrinfo (result); |
| 907 __xmlIOErr(XML_FROM_FTP, 0, "getaddrinfo failed"); |
| 908 return (-1); |
| 909 } |
| 910 if (tmp->ai_addrlen > sizeof(ctxt->ftpAddr)) { |
| 911 if (result) |
| 912 freeaddrinfo (result); |
| 913 __xmlIOErr(XML_FROM_FTP, 0, "gethostbyname address mismatch"); |
| 914 return (-1); |
| 915 } |
| 916 if (tmp->ai_family == AF_INET6) { |
| 917 memcpy (&ctxt->ftpAddr, tmp->ai_addr, tmp->ai_addrlen); |
| 918 ((struct sockaddr_in6 *) &ctxt->ftpAddr)->sin6_port = htons (port); |
| 919 ctxt->controlFd = socket (AF_INET6, SOCK_STREAM, 0); |
| 920 } |
| 921 else { |
| 922 memcpy (&ctxt->ftpAddr, tmp->ai_addr, tmp->ai_addrlen); |
| 923 ((struct sockaddr_in *) &ctxt->ftpAddr)->sin_port = htons (port); |
| 924 ctxt->controlFd = socket (AF_INET, SOCK_STREAM, 0); |
| 925 } |
| 926 addrlen = tmp->ai_addrlen; |
| 927 freeaddrinfo (result); |
| 928 } |
| 929 else |
| 930 #endif |
| 931 { |
| 932 if (proxy) |
| 933 hp = gethostbyname (GETHOSTBYNAME_ARG_CAST proxy); |
| 934 else |
| 935 hp = gethostbyname (GETHOSTBYNAME_ARG_CAST ctxt->hostname); |
| 936 if (hp == NULL) { |
| 937 __xmlIOErr(XML_FROM_FTP, 0, "gethostbyname failed"); |
| 938 return (-1); |
| 939 } |
| 940 if ((unsigned int) hp->h_length > |
| 941 sizeof(((struct sockaddr_in *)&ctxt->ftpAddr)->sin_addr)) { |
| 942 __xmlIOErr(XML_FROM_FTP, 0, "gethostbyname address mismatch"); |
| 943 return (-1); |
| 944 } |
| 945 |
| 946 /* |
| 947 * Prepare the socket |
| 948 */ |
| 949 ((struct sockaddr_in *)&ctxt->ftpAddr)->sin_family = AF_INET; |
| 950 memcpy (&((struct sockaddr_in *)&ctxt->ftpAddr)->sin_addr, |
| 951 hp->h_addr_list[0], hp->h_length); |
| 952 ((struct sockaddr_in *)&ctxt->ftpAddr)->sin_port = |
| 953 (unsigned short)htons ((unsigned short)port); |
| 954 ctxt->controlFd = socket (AF_INET, SOCK_STREAM, 0); |
| 955 addrlen = sizeof (struct sockaddr_in); |
| 956 } |
| 957 |
| 958 if (ctxt->controlFd == INVALID_SOCKET) { |
| 959 __xmlIOErr(XML_FROM_FTP, 0, "socket failed"); |
| 960 return(-1); |
| 961 } |
| 962 |
| 963 /* |
| 964 * Do the connect. |
| 965 */ |
| 966 if (connect(ctxt->controlFd, (struct sockaddr *) &ctxt->ftpAddr, |
| 967 addrlen) < 0) { |
| 968 __xmlIOErr(XML_FROM_FTP, 0, "Failed to create a connection"); |
| 969 closesocket(ctxt->controlFd); ctxt->controlFd = INVALID_SOCKET; |
| 970 ctxt->controlFd = INVALID_SOCKET; |
| 971 return(-1); |
| 972 } |
| 973 |
| 974 /* |
| 975 * Wait for the HELLO from the server. |
| 976 */ |
| 977 res = xmlNanoFTPGetResponse(ctxt); |
| 978 if (res != 2) { |
| 979 closesocket(ctxt->controlFd); ctxt->controlFd = INVALID_SOCKET; |
| 980 ctxt->controlFd = INVALID_SOCKET; |
| 981 return(-1); |
| 982 } |
| 983 |
| 984 /* |
| 985 * State diagram for the login operation on the FTP server |
| 986 * |
| 987 * Reference: RFC 959 |
| 988 * |
| 989 * 1 |
| 990 * +---+ USER +---+------------->+---+ |
| 991 * | B |---------->| W | 2 ---->| E | |
| 992 * +---+ +---+------ | -->+---+ |
| 993 * | | | | | |
| 994 * 3 | | 4,5 | | | |
| 995 * -------------- ----- | | | |
| 996 * | | | | | |
| 997 * | | | | | |
| 998 * | --------- | |
| 999 * | 1| | | | |
| 1000 * V | | | | |
| 1001 * +---+ PASS +---+ 2 | ------>+---+ |
| 1002 * | |---------->| W |------------->| S | |
| 1003 * +---+ +---+ ---------->+---+ |
| 1004 * | | | | | |
| 1005 * 3 | |4,5| | | |
| 1006 * -------------- -------- | |
| 1007 * | | | | | |
| 1008 * | | | | | |
| 1009 * | ----------- |
| 1010 * | 1,3| | | | |
| 1011 * V | 2| | | |
| 1012 * +---+ ACCT +---+-- | ----->+---+ |
| 1013 * | |---------->| W | 4,5 -------->| F | |
| 1014 * +---+ +---+------------->+---+ |
| 1015 * |
| 1016 * Of course in case of using a proxy this get really nasty and is not |
| 1017 * standardized at all :-( |
| 1018 */ |
| 1019 if (proxy) { |
| 1020 int len; |
| 1021 char buf[400]; |
| 1022 |
| 1023 if (proxyUser != NULL) { |
| 1024 /* |
| 1025 * We need proxy auth |
| 1026 */ |
| 1027 snprintf(buf, sizeof(buf), "USER %s\r\n", proxyUser); |
| 1028 buf[sizeof(buf) - 1] = 0; |
| 1029 len = strlen(buf); |
| 1030 #ifdef DEBUG_FTP |
| 1031 xmlGenericError(xmlGenericErrorContext, "%s", buf); |
| 1032 #endif |
| 1033 res = send(ctxt->controlFd, SEND_ARG2_CAST buf, len, 0); |
| 1034 if (res < 0) { |
| 1035 __xmlIOErr(XML_FROM_FTP, 0, "send failed"); |
| 1036 closesocket(ctxt->controlFd); |
| 1037 ctxt->controlFd = INVALID_SOCKET; |
| 1038 return(res); |
| 1039 } |
| 1040 res = xmlNanoFTPGetResponse(ctxt); |
| 1041 switch (res) { |
| 1042 case 2: |
| 1043 if (proxyPasswd == NULL) |
| 1044 break; |
| 1045 case 3: |
| 1046 if (proxyPasswd != NULL) |
| 1047 snprintf(buf, sizeof(buf), "PASS %s\r\n", proxyPasswd); |
| 1048 else |
| 1049 snprintf(buf, sizeof(buf), "PASS anonymous@\r\n"); |
| 1050 buf[sizeof(buf) - 1] = 0; |
| 1051 len = strlen(buf); |
| 1052 #ifdef DEBUG_FTP |
| 1053 xmlGenericError(xmlGenericErrorContext, "%s", buf); |
| 1054 #endif |
| 1055 res = send(ctxt->controlFd, SEND_ARG2_CAST buf, len, 0); |
| 1056 if (res < 0) { |
| 1057 __xmlIOErr(XML_FROM_FTP, 0, "send failed"); |
| 1058 closesocket(ctxt->controlFd); |
| 1059 ctxt->controlFd = INVALID_SOCKET; |
| 1060 return(res); |
| 1061 } |
| 1062 res = xmlNanoFTPGetResponse(ctxt); |
| 1063 if (res > 3) { |
| 1064 closesocket(ctxt->controlFd); |
| 1065 ctxt->controlFd = INVALID_SOCKET; |
| 1066 return(-1); |
| 1067 } |
| 1068 break; |
| 1069 case 1: |
| 1070 break; |
| 1071 case 4: |
| 1072 case 5: |
| 1073 case -1: |
| 1074 default: |
| 1075 closesocket(ctxt->controlFd); |
| 1076 ctxt->controlFd = INVALID_SOCKET; |
| 1077 return(-1); |
| 1078 } |
| 1079 } |
| 1080 |
| 1081 /* |
| 1082 * We assume we don't need more authentication to the proxy |
| 1083 * and that it succeeded :-\ |
| 1084 */ |
| 1085 switch (proxyType) { |
| 1086 case 0: |
| 1087 /* we will try in sequence */ |
| 1088 case 1: |
| 1089 /* Using SITE command */ |
| 1090 snprintf(buf, sizeof(buf), "SITE %s\r\n", ctxt->hostname); |
| 1091 buf[sizeof(buf) - 1] = 0; |
| 1092 len = strlen(buf); |
| 1093 #ifdef DEBUG_FTP |
| 1094 xmlGenericError(xmlGenericErrorContext, "%s", buf); |
| 1095 #endif |
| 1096 res = send(ctxt->controlFd, SEND_ARG2_CAST buf, len, 0); |
| 1097 if (res < 0) { |
| 1098 __xmlIOErr(XML_FROM_FTP, 0, "send failed"); |
| 1099 closesocket(ctxt->controlFd); ctxt->controlFd = INVALID_SOCK
ET; |
| 1100 ctxt->controlFd = INVALID_SOCKET; |
| 1101 return(res); |
| 1102 } |
| 1103 res = xmlNanoFTPGetResponse(ctxt); |
| 1104 if (res == 2) { |
| 1105 /* we assume it worked :-\ 1 is error for SITE command */ |
| 1106 proxyType = 1; |
| 1107 break; |
| 1108 } |
| 1109 if (proxyType == 1) { |
| 1110 closesocket(ctxt->controlFd); ctxt->controlFd = INVALID_SOCK
ET; |
| 1111 ctxt->controlFd = INVALID_SOCKET; |
| 1112 return(-1); |
| 1113 } |
| 1114 case 2: |
| 1115 /* USER user@host command */ |
| 1116 if (ctxt->user == NULL) |
| 1117 snprintf(buf, sizeof(buf), "USER anonymous@%s\r\n", |
| 1118 ctxt->hostname); |
| 1119 else |
| 1120 snprintf(buf, sizeof(buf), "USER %s@%s\r\n", |
| 1121 ctxt->user, ctxt->hostname); |
| 1122 buf[sizeof(buf) - 1] = 0; |
| 1123 len = strlen(buf); |
| 1124 #ifdef DEBUG_FTP |
| 1125 xmlGenericError(xmlGenericErrorContext, "%s", buf); |
| 1126 #endif |
| 1127 res = send(ctxt->controlFd, SEND_ARG2_CAST buf, len, 0); |
| 1128 if (res < 0) { |
| 1129 __xmlIOErr(XML_FROM_FTP, 0, "send failed"); |
| 1130 closesocket(ctxt->controlFd); ctxt->controlFd = INVALID_SOCK
ET; |
| 1131 ctxt->controlFd = INVALID_SOCKET; |
| 1132 return(res); |
| 1133 } |
| 1134 res = xmlNanoFTPGetResponse(ctxt); |
| 1135 if ((res == 1) || (res == 2)) { |
| 1136 /* we assume it worked :-\ */ |
| 1137 proxyType = 2; |
| 1138 return(0); |
| 1139 } |
| 1140 if (ctxt->passwd == NULL) |
| 1141 snprintf(buf, sizeof(buf), "PASS anonymous@\r\n"); |
| 1142 else |
| 1143 snprintf(buf, sizeof(buf), "PASS %s\r\n", ctxt->passwd); |
| 1144 buf[sizeof(buf) - 1] = 0; |
| 1145 len = strlen(buf); |
| 1146 #ifdef DEBUG_FTP |
| 1147 xmlGenericError(xmlGenericErrorContext, "%s", buf); |
| 1148 #endif |
| 1149 res = send(ctxt->controlFd, SEND_ARG2_CAST buf, len, 0); |
| 1150 if (res < 0) { |
| 1151 __xmlIOErr(XML_FROM_FTP, 0, "send failed"); |
| 1152 closesocket(ctxt->controlFd); ctxt->controlFd = INVALID_SOCK
ET; |
| 1153 ctxt->controlFd = INVALID_SOCKET; |
| 1154 return(res); |
| 1155 } |
| 1156 res = xmlNanoFTPGetResponse(ctxt); |
| 1157 if ((res == 1) || (res == 2)) { |
| 1158 /* we assume it worked :-\ */ |
| 1159 proxyType = 2; |
| 1160 return(0); |
| 1161 } |
| 1162 if (proxyType == 2) { |
| 1163 closesocket(ctxt->controlFd); ctxt->controlFd = INVALID_SOCK
ET; |
| 1164 ctxt->controlFd = INVALID_SOCKET; |
| 1165 return(-1); |
| 1166 } |
| 1167 case 3: |
| 1168 /* |
| 1169 * If you need support for other Proxy authentication scheme |
| 1170 * send the code or at least the sequence in use. |
| 1171 */ |
| 1172 default: |
| 1173 closesocket(ctxt->controlFd); ctxt->controlFd = INVALID_SOCKET; |
| 1174 ctxt->controlFd = INVALID_SOCKET; |
| 1175 return(-1); |
| 1176 } |
| 1177 } |
| 1178 /* |
| 1179 * Non-proxy handling. |
| 1180 */ |
| 1181 res = xmlNanoFTPSendUser(ctxt); |
| 1182 if (res < 0) { |
| 1183 closesocket(ctxt->controlFd); ctxt->controlFd = INVALID_SOCKET; |
| 1184 ctxt->controlFd = INVALID_SOCKET; |
| 1185 return(-1); |
| 1186 } |
| 1187 res = xmlNanoFTPGetResponse(ctxt); |
| 1188 switch (res) { |
| 1189 case 2: |
| 1190 return(0); |
| 1191 case 3: |
| 1192 break; |
| 1193 case 1: |
| 1194 case 4: |
| 1195 case 5: |
| 1196 case -1: |
| 1197 default: |
| 1198 closesocket(ctxt->controlFd); ctxt->controlFd = INVALID_SOCKET; |
| 1199 ctxt->controlFd = INVALID_SOCKET; |
| 1200 return(-1); |
| 1201 } |
| 1202 res = xmlNanoFTPSendPasswd(ctxt); |
| 1203 if (res < 0) { |
| 1204 closesocket(ctxt->controlFd); ctxt->controlFd = INVALID_SOCKET; |
| 1205 ctxt->controlFd = INVALID_SOCKET; |
| 1206 return(-1); |
| 1207 } |
| 1208 res = xmlNanoFTPGetResponse(ctxt); |
| 1209 switch (res) { |
| 1210 case 2: |
| 1211 break; |
| 1212 case 3: |
| 1213 __xmlIOErr(XML_FROM_FTP, XML_FTP_ACCNT, |
| 1214 "FTP server asking for ACCNT on anonymous\n"); |
| 1215 case 1: |
| 1216 case 4: |
| 1217 case 5: |
| 1218 case -1: |
| 1219 default: |
| 1220 closesocket(ctxt->controlFd); ctxt->controlFd = INVALID_SOCKET; |
| 1221 ctxt->controlFd = INVALID_SOCKET; |
| 1222 return(-1); |
| 1223 } |
| 1224 |
| 1225 return(0); |
| 1226 } |
| 1227 |
| 1228 /** |
| 1229 * xmlNanoFTPConnectTo: |
| 1230 * @server: an FTP server name |
| 1231 * @port: the port (use 21 if 0) |
| 1232 * |
| 1233 * Tries to open a control connection to the given server/port |
| 1234 * |
| 1235 * Returns an fTP context or NULL if it failed |
| 1236 */ |
| 1237 |
| 1238 void* |
| 1239 xmlNanoFTPConnectTo(const char *server, int port) { |
| 1240 xmlNanoFTPCtxtPtr ctxt; |
| 1241 int res; |
| 1242 |
| 1243 xmlNanoFTPInit(); |
| 1244 if (server == NULL) |
| 1245 return(NULL); |
| 1246 if (port <= 0) |
| 1247 return(NULL); |
| 1248 ctxt = (xmlNanoFTPCtxtPtr) xmlNanoFTPNewCtxt(NULL); |
| 1249 if (ctxt == NULL) |
| 1250 return(NULL); |
| 1251 ctxt->hostname = xmlMemStrdup(server); |
| 1252 if (ctxt->hostname == NULL) { |
| 1253 xmlNanoFTPFreeCtxt(ctxt); |
| 1254 return(NULL); |
| 1255 } |
| 1256 if (port != 0) |
| 1257 ctxt->port = port; |
| 1258 res = xmlNanoFTPConnect(ctxt); |
| 1259 if (res < 0) { |
| 1260 xmlNanoFTPFreeCtxt(ctxt); |
| 1261 return(NULL); |
| 1262 } |
| 1263 return(ctxt); |
| 1264 } |
| 1265 |
| 1266 /** |
| 1267 * xmlNanoFTPCwd: |
| 1268 * @ctx: an FTP context |
| 1269 * @directory: a directory on the server |
| 1270 * |
| 1271 * Tries to change the remote directory |
| 1272 * |
| 1273 * Returns -1 incase of error, 1 if CWD worked, 0 if it failed |
| 1274 */ |
| 1275 |
| 1276 int |
| 1277 xmlNanoFTPCwd(void *ctx, const char *directory) { |
| 1278 xmlNanoFTPCtxtPtr ctxt = (xmlNanoFTPCtxtPtr) ctx; |
| 1279 char buf[400]; |
| 1280 int len; |
| 1281 int res; |
| 1282 |
| 1283 if ((ctxt == NULL) || (ctxt->controlFd == INVALID_SOCKET)) return(-1); |
| 1284 if (directory == NULL) return 0; |
| 1285 |
| 1286 /* |
| 1287 * Expected response code for CWD: |
| 1288 * |
| 1289 * CWD |
| 1290 * 250 |
| 1291 * 500, 501, 502, 421, 530, 550 |
| 1292 */ |
| 1293 snprintf(buf, sizeof(buf), "CWD %s\r\n", directory); |
| 1294 buf[sizeof(buf) - 1] = 0; |
| 1295 len = strlen(buf); |
| 1296 #ifdef DEBUG_FTP |
| 1297 xmlGenericError(xmlGenericErrorContext, "%s", buf); |
| 1298 #endif |
| 1299 res = send(ctxt->controlFd, SEND_ARG2_CAST buf, len, 0); |
| 1300 if (res < 0) { |
| 1301 __xmlIOErr(XML_FROM_FTP, 0, "send failed"); |
| 1302 return(res); |
| 1303 } |
| 1304 res = xmlNanoFTPGetResponse(ctxt); |
| 1305 if (res == 4) { |
| 1306 return(-1); |
| 1307 } |
| 1308 if (res == 2) return(1); |
| 1309 if (res == 5) { |
| 1310 return(0); |
| 1311 } |
| 1312 return(0); |
| 1313 } |
| 1314 |
| 1315 /** |
| 1316 * xmlNanoFTPDele: |
| 1317 * @ctx: an FTP context |
| 1318 * @file: a file or directory on the server |
| 1319 * |
| 1320 * Tries to delete an item (file or directory) from server |
| 1321 * |
| 1322 * Returns -1 incase of error, 1 if DELE worked, 0 if it failed |
| 1323 */ |
| 1324 |
| 1325 int |
| 1326 xmlNanoFTPDele(void *ctx, const char *file) { |
| 1327 xmlNanoFTPCtxtPtr ctxt = (xmlNanoFTPCtxtPtr) ctx; |
| 1328 char buf[400]; |
| 1329 int len; |
| 1330 int res; |
| 1331 |
| 1332 if ((ctxt == NULL) || (ctxt->controlFd == INVALID_SOCKET) || |
| 1333 (file == NULL)) return(-1); |
| 1334 |
| 1335 /* |
| 1336 * Expected response code for DELE: |
| 1337 * |
| 1338 * DELE |
| 1339 * 250 |
| 1340 * 450, 550 |
| 1341 * 500, 501, 502, 421, 530 |
| 1342 */ |
| 1343 |
| 1344 snprintf(buf, sizeof(buf), "DELE %s\r\n", file); |
| 1345 buf[sizeof(buf) - 1] = 0; |
| 1346 len = strlen(buf); |
| 1347 #ifdef DEBUG_FTP |
| 1348 xmlGenericError(xmlGenericErrorContext, "%s", buf); |
| 1349 #endif |
| 1350 res = send(ctxt->controlFd, SEND_ARG2_CAST buf, len, 0); |
| 1351 if (res < 0) { |
| 1352 __xmlIOErr(XML_FROM_FTP, 0, "send failed"); |
| 1353 return(res); |
| 1354 } |
| 1355 res = xmlNanoFTPGetResponse(ctxt); |
| 1356 if (res == 4) { |
| 1357 return(-1); |
| 1358 } |
| 1359 if (res == 2) return(1); |
| 1360 if (res == 5) { |
| 1361 return(0); |
| 1362 } |
| 1363 return(0); |
| 1364 } |
| 1365 /** |
| 1366 * xmlNanoFTPGetConnection: |
| 1367 * @ctx: an FTP context |
| 1368 * |
| 1369 * Try to open a data connection to the server. Currently only |
| 1370 * passive mode is supported. |
| 1371 * |
| 1372 * Returns -1 incase of error, 0 otherwise |
| 1373 */ |
| 1374 |
| 1375 SOCKET |
| 1376 xmlNanoFTPGetConnection(void *ctx) { |
| 1377 xmlNanoFTPCtxtPtr ctxt = (xmlNanoFTPCtxtPtr) ctx; |
| 1378 char buf[200], *cur; |
| 1379 int len, i; |
| 1380 int res; |
| 1381 unsigned char ad[6], *adp, *portp; |
| 1382 unsigned int temp[6]; |
| 1383 #ifdef SUPPORT_IP6 |
| 1384 struct sockaddr_storage dataAddr; |
| 1385 #else |
| 1386 struct sockaddr_in dataAddr; |
| 1387 #endif |
| 1388 XML_SOCKLEN_T dataAddrLen; |
| 1389 |
| 1390 if (ctxt == NULL) return INVALID_SOCKET; |
| 1391 |
| 1392 memset (&dataAddr, 0, sizeof(dataAddr)); |
| 1393 #ifdef SUPPORT_IP6 |
| 1394 if ((ctxt->ftpAddr).ss_family == AF_INET6) { |
| 1395 ctxt->dataFd = socket (AF_INET6, SOCK_STREAM, IPPROTO_TCP); |
| 1396 ((struct sockaddr_in6 *)&dataAddr)->sin6_family = AF_INET6; |
| 1397 dataAddrLen = sizeof(struct sockaddr_in6); |
| 1398 } else |
| 1399 #endif |
| 1400 { |
| 1401 ctxt->dataFd = socket (AF_INET, SOCK_STREAM, IPPROTO_TCP); |
| 1402 ((struct sockaddr_in *)&dataAddr)->sin_family = AF_INET; |
| 1403 dataAddrLen = sizeof (struct sockaddr_in); |
| 1404 } |
| 1405 |
| 1406 if (ctxt->dataFd == INVALID_SOCKET) { |
| 1407 __xmlIOErr(XML_FROM_FTP, 0, "socket failed"); |
| 1408 return INVALID_SOCKET; |
| 1409 } |
| 1410 |
| 1411 if (ctxt->passive) { |
| 1412 #ifdef SUPPORT_IP6 |
| 1413 if ((ctxt->ftpAddr).ss_family == AF_INET6) |
| 1414 snprintf (buf, sizeof(buf), "EPSV\r\n"); |
| 1415 else |
| 1416 #endif |
| 1417 snprintf (buf, sizeof(buf), "PASV\r\n"); |
| 1418 len = strlen (buf); |
| 1419 #ifdef DEBUG_FTP |
| 1420 xmlGenericError(xmlGenericErrorContext, "%s", buf); |
| 1421 #endif |
| 1422 res = send(ctxt->controlFd, SEND_ARG2_CAST buf, len, 0); |
| 1423 if (res < 0) { |
| 1424 __xmlIOErr(XML_FROM_FTP, 0, "send failed"); |
| 1425 closesocket(ctxt->dataFd); ctxt->dataFd = INVALID_SOCKET; |
| 1426 return INVALID_SOCKET; |
| 1427 } |
| 1428 res = xmlNanoFTPReadResponse(ctx); |
| 1429 if (res != 2) { |
| 1430 if (res == 5) { |
| 1431 closesocket(ctxt->dataFd); ctxt->dataFd = INVALID_SOCKET; |
| 1432 return INVALID_SOCKET; |
| 1433 } else { |
| 1434 /* |
| 1435 * retry with an active connection |
| 1436 */ |
| 1437 closesocket(ctxt->dataFd); ctxt->dataFd = INVALID_SOCKET; |
| 1438 ctxt->passive = 0; |
| 1439 } |
| 1440 } |
| 1441 cur = &ctxt->controlBuf[ctxt->controlBufAnswer]; |
| 1442 while (((*cur < '0') || (*cur > '9')) && *cur != '\0') cur++; |
| 1443 #ifdef SUPPORT_IP6 |
| 1444 if ((ctxt->ftpAddr).ss_family == AF_INET6) { |
| 1445 if (sscanf (cur, "%u", &temp[0]) != 1) { |
| 1446 __xmlIOErr(XML_FROM_FTP, XML_FTP_EPSV_ANSWER, |
| 1447 "Invalid answer to EPSV\n"); |
| 1448 if (ctxt->dataFd != INVALID_SOCKET) { |
| 1449 closesocket (ctxt->dataFd); ctxt->dataFd = INVALID_SOCKET; |
| 1450 } |
| 1451 return INVALID_SOCKET; |
| 1452 } |
| 1453 memcpy (&((struct sockaddr_in6 *)&dataAddr)->sin6_addr, &((struct so
ckaddr_in6 *)&ctxt->ftpAddr)->sin6_addr, sizeof(struct in6_addr)); |
| 1454 ((struct sockaddr_in6 *)&dataAddr)->sin6_port = htons (temp[0]); |
| 1455 } |
| 1456 else |
| 1457 #endif |
| 1458 { |
| 1459 if (sscanf (cur, "%u,%u,%u,%u,%u,%u", &temp[0], &temp[1], &temp[2], |
| 1460 &temp[3], &temp[4], &temp[5]) != 6) { |
| 1461 __xmlIOErr(XML_FROM_FTP, XML_FTP_PASV_ANSWER, |
| 1462 "Invalid answer to PASV\n"); |
| 1463 if (ctxt->dataFd != INVALID_SOCKET) { |
| 1464 closesocket (ctxt->dataFd); ctxt->dataFd = INVALID_SOCKET; |
| 1465 } |
| 1466 return INVALID_SOCKET; |
| 1467 } |
| 1468 for (i=0; i<6; i++) ad[i] = (unsigned char) (temp[i] & 0xff); |
| 1469 memcpy (&((struct sockaddr_in *)&dataAddr)->sin_addr, &ad[0], 4); |
| 1470 memcpy (&((struct sockaddr_in *)&dataAddr)->sin_port, &ad[4], 2); |
| 1471 } |
| 1472 |
| 1473 if (connect(ctxt->dataFd, (struct sockaddr *) &dataAddr, dataAddrLen) <
0) { |
| 1474 __xmlIOErr(XML_FROM_FTP, 0, "Failed to create a data connection"); |
| 1475 closesocket(ctxt->dataFd); ctxt->dataFd = INVALID_SOCKET; |
| 1476 return INVALID_SOCKET; |
| 1477 } |
| 1478 } else { |
| 1479 getsockname(ctxt->dataFd, (struct sockaddr *) &dataAddr, &dataAddrLen); |
| 1480 #ifdef SUPPORT_IP6 |
| 1481 if ((ctxt->ftpAddr).ss_family == AF_INET6) |
| 1482 ((struct sockaddr_in6 *)&dataAddr)->sin6_port = 0; |
| 1483 else |
| 1484 #endif |
| 1485 ((struct sockaddr_in *)&dataAddr)->sin_port = 0; |
| 1486 |
| 1487 if (bind(ctxt->dataFd, (struct sockaddr *) &dataAddr, dataAddrLen) < 0)
{ |
| 1488 __xmlIOErr(XML_FROM_FTP, 0, "bind failed"); |
| 1489 closesocket(ctxt->dataFd); ctxt->dataFd = INVALID_SOCKET; |
| 1490 return INVALID_SOCKET; |
| 1491 } |
| 1492 getsockname(ctxt->dataFd, (struct sockaddr *) &dataAddr, &dataAddrLen); |
| 1493 |
| 1494 if (listen(ctxt->dataFd, 1) < 0) { |
| 1495 __xmlIOErr(XML_FROM_FTP, 0, "listen failed"); |
| 1496 closesocket(ctxt->dataFd); ctxt->dataFd = INVALID_SOCKET; |
| 1497 return INVALID_SOCKET; |
| 1498 } |
| 1499 #ifdef SUPPORT_IP6 |
| 1500 if ((ctxt->ftpAddr).ss_family == AF_INET6) { |
| 1501 char buf6[INET6_ADDRSTRLEN]; |
| 1502 inet_ntop (AF_INET6, &((struct sockaddr_in6 *)&dataAddr)->sin6_addr, |
| 1503 buf6, INET6_ADDRSTRLEN); |
| 1504 adp = (unsigned char *) buf6; |
| 1505 portp = (unsigned char *) &((struct sockaddr_in6 *)&dataAddr)->sin6_
port; |
| 1506 snprintf (buf, sizeof(buf), "EPRT |2|%s|%s|\r\n", adp, portp); |
| 1507 } else |
| 1508 #endif |
| 1509 { |
| 1510 adp = (unsigned char *) &((struct sockaddr_in *)&dataAddr)->sin_addr
; |
| 1511 portp = (unsigned char *) &((struct sockaddr_in *)&dataAddr)->sin_po
rt; |
| 1512 snprintf (buf, sizeof(buf), "PORT %d,%d,%d,%d,%d,%d\r\n", |
| 1513 adp[0] & 0xff, adp[1] & 0xff, adp[2] & 0xff, adp[3] & 0xff, |
| 1514 portp[0] & 0xff, portp[1] & 0xff); |
| 1515 } |
| 1516 |
| 1517 buf[sizeof(buf) - 1] = 0; |
| 1518 len = strlen(buf); |
| 1519 #ifdef DEBUG_FTP |
| 1520 xmlGenericError(xmlGenericErrorContext, "%s", buf); |
| 1521 #endif |
| 1522 |
| 1523 res = send(ctxt->controlFd, SEND_ARG2_CAST buf, len, 0); |
| 1524 if (res < 0) { |
| 1525 __xmlIOErr(XML_FROM_FTP, 0, "send failed"); |
| 1526 closesocket(ctxt->dataFd); ctxt->dataFd = INVALID_SOCKET; |
| 1527 return INVALID_SOCKET; |
| 1528 } |
| 1529 res = xmlNanoFTPGetResponse(ctxt); |
| 1530 if (res != 2) { |
| 1531 closesocket(ctxt->dataFd); ctxt->dataFd = INVALID_SOCKET; |
| 1532 return INVALID_SOCKET; |
| 1533 } |
| 1534 } |
| 1535 return(ctxt->dataFd); |
| 1536 |
| 1537 } |
| 1538 |
| 1539 /** |
| 1540 * xmlNanoFTPCloseConnection: |
| 1541 * @ctx: an FTP context |
| 1542 * |
| 1543 * Close the data connection from the server |
| 1544 * |
| 1545 * Returns -1 incase of error, 0 otherwise |
| 1546 */ |
| 1547 |
| 1548 int |
| 1549 xmlNanoFTPCloseConnection(void *ctx) { |
| 1550 xmlNanoFTPCtxtPtr ctxt = (xmlNanoFTPCtxtPtr) ctx; |
| 1551 int res; |
| 1552 fd_set rfd, efd; |
| 1553 struct timeval tv; |
| 1554 |
| 1555 if ((ctxt == NULL) || (ctxt->controlFd == INVALID_SOCKET)) return(-1); |
| 1556 |
| 1557 closesocket(ctxt->dataFd); ctxt->dataFd = INVALID_SOCKET; |
| 1558 tv.tv_sec = 15; |
| 1559 tv.tv_usec = 0; |
| 1560 FD_ZERO(&rfd); |
| 1561 FD_SET(ctxt->controlFd, &rfd); |
| 1562 FD_ZERO(&efd); |
| 1563 FD_SET(ctxt->controlFd, &efd); |
| 1564 res = select(ctxt->controlFd + 1, &rfd, NULL, &efd, &tv); |
| 1565 if (res < 0) { |
| 1566 #ifdef DEBUG_FTP |
| 1567 perror("select"); |
| 1568 #endif |
| 1569 closesocket(ctxt->controlFd); ctxt->controlFd = INVALID_SOCKET; |
| 1570 return(-1); |
| 1571 } |
| 1572 if (res == 0) { |
| 1573 #ifdef DEBUG_FTP |
| 1574 xmlGenericError(xmlGenericErrorContext, |
| 1575 "xmlNanoFTPCloseConnection: timeout\n"); |
| 1576 #endif |
| 1577 closesocket(ctxt->controlFd); ctxt->controlFd = INVALID_SOCKET; |
| 1578 } else { |
| 1579 res = xmlNanoFTPGetResponse(ctxt); |
| 1580 if (res != 2) { |
| 1581 closesocket(ctxt->controlFd); ctxt->controlFd = INVALID_SOCKET; |
| 1582 return(-1); |
| 1583 } |
| 1584 } |
| 1585 return(0); |
| 1586 } |
| 1587 |
| 1588 /** |
| 1589 * xmlNanoFTPParseList: |
| 1590 * @list: some data listing received from the server |
| 1591 * @callback: the user callback |
| 1592 * @userData: the user callback data |
| 1593 * |
| 1594 * Parse at most one entry from the listing. |
| 1595 * |
| 1596 * Returns -1 incase of error, the length of data parsed otherwise |
| 1597 */ |
| 1598 |
| 1599 static int |
| 1600 xmlNanoFTPParseList(const char *list, ftpListCallback callback, void *userData)
{ |
| 1601 const char *cur = list; |
| 1602 char filename[151]; |
| 1603 char attrib[11]; |
| 1604 char owner[11]; |
| 1605 char group[11]; |
| 1606 char month[4]; |
| 1607 int year = 0; |
| 1608 int minute = 0; |
| 1609 int hour = 0; |
| 1610 int day = 0; |
| 1611 unsigned long size = 0; |
| 1612 int links = 0; |
| 1613 int i; |
| 1614 |
| 1615 if (!strncmp(cur, "total", 5)) { |
| 1616 cur += 5; |
| 1617 while (*cur == ' ') cur++; |
| 1618 while ((*cur >= '0') && (*cur <= '9')) |
| 1619 links = (links * 10) + (*cur++ - '0'); |
| 1620 while ((*cur == ' ') || (*cur == '\n') || (*cur == '\r')) |
| 1621 cur++; |
| 1622 return(cur - list); |
| 1623 } else if (*list == '+') { |
| 1624 return(0); |
| 1625 } else { |
| 1626 while ((*cur == ' ') || (*cur == '\n') || (*cur == '\r')) |
| 1627 cur++; |
| 1628 if (*cur == 0) return(0); |
| 1629 i = 0; |
| 1630 while (*cur != ' ') { |
| 1631 if (i < 10) |
| 1632 attrib[i++] = *cur; |
| 1633 cur++; |
| 1634 if (*cur == 0) return(0); |
| 1635 } |
| 1636 attrib[10] = 0; |
| 1637 while (*cur == ' ') cur++; |
| 1638 if (*cur == 0) return(0); |
| 1639 while ((*cur >= '0') && (*cur <= '9')) |
| 1640 links = (links * 10) + (*cur++ - '0'); |
| 1641 while (*cur == ' ') cur++; |
| 1642 if (*cur == 0) return(0); |
| 1643 i = 0; |
| 1644 while (*cur != ' ') { |
| 1645 if (i < 10) |
| 1646 owner[i++] = *cur; |
| 1647 cur++; |
| 1648 if (*cur == 0) return(0); |
| 1649 } |
| 1650 owner[i] = 0; |
| 1651 while (*cur == ' ') cur++; |
| 1652 if (*cur == 0) return(0); |
| 1653 i = 0; |
| 1654 while (*cur != ' ') { |
| 1655 if (i < 10) |
| 1656 group[i++] = *cur; |
| 1657 cur++; |
| 1658 if (*cur == 0) return(0); |
| 1659 } |
| 1660 group[i] = 0; |
| 1661 while (*cur == ' ') cur++; |
| 1662 if (*cur == 0) return(0); |
| 1663 while ((*cur >= '0') && (*cur <= '9')) |
| 1664 size = (size * 10) + (*cur++ - '0'); |
| 1665 while (*cur == ' ') cur++; |
| 1666 if (*cur == 0) return(0); |
| 1667 i = 0; |
| 1668 while (*cur != ' ') { |
| 1669 if (i < 3) |
| 1670 month[i++] = *cur; |
| 1671 cur++; |
| 1672 if (*cur == 0) return(0); |
| 1673 } |
| 1674 month[i] = 0; |
| 1675 while (*cur == ' ') cur++; |
| 1676 if (*cur == 0) return(0); |
| 1677 while ((*cur >= '0') && (*cur <= '9')) |
| 1678 day = (day * 10) + (*cur++ - '0'); |
| 1679 while (*cur == ' ') cur++; |
| 1680 if (*cur == 0) return(0); |
| 1681 if ((cur[1] == 0) || (cur[2] == 0)) return(0); |
| 1682 if ((cur[1] == ':') || (cur[2] == ':')) { |
| 1683 while ((*cur >= '0') && (*cur <= '9')) |
| 1684 hour = (hour * 10) + (*cur++ - '0'); |
| 1685 if (*cur == ':') cur++; |
| 1686 while ((*cur >= '0') && (*cur <= '9')) |
| 1687 minute = (minute * 10) + (*cur++ - '0'); |
| 1688 } else { |
| 1689 while ((*cur >= '0') && (*cur <= '9')) |
| 1690 year = (year * 10) + (*cur++ - '0'); |
| 1691 } |
| 1692 while (*cur == ' ') cur++; |
| 1693 if (*cur == 0) return(0); |
| 1694 i = 0; |
| 1695 while ((*cur != '\n') && (*cur != '\r')) { |
| 1696 if (i < 150) |
| 1697 filename[i++] = *cur; |
| 1698 cur++; |
| 1699 if (*cur == 0) return(0); |
| 1700 } |
| 1701 filename[i] = 0; |
| 1702 if ((*cur != '\n') && (*cur != '\r')) |
| 1703 return(0); |
| 1704 while ((*cur == '\n') || (*cur == '\r')) |
| 1705 cur++; |
| 1706 } |
| 1707 if (callback != NULL) { |
| 1708 callback(userData, filename, attrib, owner, group, size, links, |
| 1709 year, month, day, hour, minute); |
| 1710 } |
| 1711 return(cur - list); |
| 1712 } |
| 1713 |
| 1714 /** |
| 1715 * xmlNanoFTPList: |
| 1716 * @ctx: an FTP context |
| 1717 * @callback: the user callback |
| 1718 * @userData: the user callback data |
| 1719 * @filename: optional files to list |
| 1720 * |
| 1721 * Do a listing on the server. All files info are passed back |
| 1722 * in the callbacks. |
| 1723 * |
| 1724 * Returns -1 incase of error, 0 otherwise |
| 1725 */ |
| 1726 |
| 1727 int |
| 1728 xmlNanoFTPList(void *ctx, ftpListCallback callback, void *userData, |
| 1729 const char *filename) { |
| 1730 xmlNanoFTPCtxtPtr ctxt = (xmlNanoFTPCtxtPtr) ctx; |
| 1731 char buf[4096 + 1]; |
| 1732 int len, res; |
| 1733 int indx = 0, base; |
| 1734 fd_set rfd, efd; |
| 1735 struct timeval tv; |
| 1736 |
| 1737 if (ctxt == NULL) return (-1); |
| 1738 if (filename == NULL) { |
| 1739 if (xmlNanoFTPCwd(ctxt, ctxt->path) < 1) |
| 1740 return(-1); |
| 1741 ctxt->dataFd = xmlNanoFTPGetConnection(ctxt); |
| 1742 if (ctxt->dataFd == INVALID_SOCKET) |
| 1743 return(-1); |
| 1744 snprintf(buf, sizeof(buf), "LIST -L\r\n"); |
| 1745 } else { |
| 1746 if (filename[0] != '/') { |
| 1747 if (xmlNanoFTPCwd(ctxt, ctxt->path) < 1) |
| 1748 return(-1); |
| 1749 } |
| 1750 ctxt->dataFd = xmlNanoFTPGetConnection(ctxt); |
| 1751 if (ctxt->dataFd == INVALID_SOCKET) |
| 1752 return(-1); |
| 1753 snprintf(buf, sizeof(buf), "LIST -L %s\r\n", filename); |
| 1754 } |
| 1755 buf[sizeof(buf) - 1] = 0; |
| 1756 len = strlen(buf); |
| 1757 #ifdef DEBUG_FTP |
| 1758 xmlGenericError(xmlGenericErrorContext, "%s", buf); |
| 1759 #endif |
| 1760 res = send(ctxt->controlFd, SEND_ARG2_CAST buf, len, 0); |
| 1761 if (res < 0) { |
| 1762 __xmlIOErr(XML_FROM_FTP, 0, "send failed"); |
| 1763 closesocket(ctxt->dataFd); ctxt->dataFd = INVALID_SOCKET; |
| 1764 return(res); |
| 1765 } |
| 1766 res = xmlNanoFTPReadResponse(ctxt); |
| 1767 if (res != 1) { |
| 1768 closesocket(ctxt->dataFd); ctxt->dataFd = INVALID_SOCKET; |
| 1769 return(-res); |
| 1770 } |
| 1771 |
| 1772 do { |
| 1773 tv.tv_sec = 1; |
| 1774 tv.tv_usec = 0; |
| 1775 FD_ZERO(&rfd); |
| 1776 FD_SET(ctxt->dataFd, &rfd); |
| 1777 FD_ZERO(&efd); |
| 1778 FD_SET(ctxt->dataFd, &efd); |
| 1779 res = select(ctxt->dataFd + 1, &rfd, NULL, &efd, &tv); |
| 1780 if (res < 0) { |
| 1781 #ifdef DEBUG_FTP |
| 1782 perror("select"); |
| 1783 #endif |
| 1784 closesocket(ctxt->dataFd); ctxt->dataFd = INVALID_SOCKET; |
| 1785 return(-1); |
| 1786 } |
| 1787 if (res == 0) { |
| 1788 res = xmlNanoFTPCheckResponse(ctxt); |
| 1789 if (res < 0) { |
| 1790 closesocket(ctxt->dataFd); ctxt->dataFd = INVALID_SOCKET; |
| 1791 ctxt->dataFd = INVALID_SOCKET; |
| 1792 return(-1); |
| 1793 } |
| 1794 if (res == 2) { |
| 1795 closesocket(ctxt->dataFd); ctxt->dataFd = INVALID_SOCKET; |
| 1796 return(0); |
| 1797 } |
| 1798 |
| 1799 continue; |
| 1800 } |
| 1801 |
| 1802 if ((len = recv(ctxt->dataFd, &buf[indx], sizeof(buf) - (indx + 1), 0))
< 0) { |
| 1803 __xmlIOErr(XML_FROM_FTP, 0, "recv"); |
| 1804 closesocket(ctxt->dataFd); ctxt->dataFd = INVALID_SOCKET; |
| 1805 ctxt->dataFd = INVALID_SOCKET; |
| 1806 return(-1); |
| 1807 } |
| 1808 #ifdef DEBUG_FTP |
| 1809 write(1, &buf[indx], len); |
| 1810 #endif |
| 1811 indx += len; |
| 1812 buf[indx] = 0; |
| 1813 base = 0; |
| 1814 do { |
| 1815 res = xmlNanoFTPParseList(&buf[base], callback, userData); |
| 1816 base += res; |
| 1817 } while (res > 0); |
| 1818 |
| 1819 memmove(&buf[0], &buf[base], indx - base); |
| 1820 indx -= base; |
| 1821 } while (len != 0); |
| 1822 xmlNanoFTPCloseConnection(ctxt); |
| 1823 return(0); |
| 1824 } |
| 1825 |
| 1826 /** |
| 1827 * xmlNanoFTPGetSocket: |
| 1828 * @ctx: an FTP context |
| 1829 * @filename: the file to retrieve (or NULL if path is in context). |
| 1830 * |
| 1831 * Initiate fetch of the given file from the server. |
| 1832 * |
| 1833 * Returns the socket for the data connection, or <0 in case of error |
| 1834 */ |
| 1835 |
| 1836 |
| 1837 SOCKET |
| 1838 xmlNanoFTPGetSocket(void *ctx, const char *filename) { |
| 1839 xmlNanoFTPCtxtPtr ctxt = (xmlNanoFTPCtxtPtr) ctx; |
| 1840 char buf[300]; |
| 1841 int res, len; |
| 1842 if (ctx == NULL) |
| 1843 return INVALID_SOCKET; |
| 1844 if ((filename == NULL) && (ctxt->path == NULL)) |
| 1845 return INVALID_SOCKET; |
| 1846 ctxt->dataFd = xmlNanoFTPGetConnection(ctxt); |
| 1847 if (ctxt->dataFd == INVALID_SOCKET) |
| 1848 return INVALID_SOCKET; |
| 1849 |
| 1850 snprintf(buf, sizeof(buf), "TYPE I\r\n"); |
| 1851 len = strlen(buf); |
| 1852 #ifdef DEBUG_FTP |
| 1853 xmlGenericError(xmlGenericErrorContext, "%s", buf); |
| 1854 #endif |
| 1855 res = send(ctxt->controlFd, SEND_ARG2_CAST buf, len, 0); |
| 1856 if (res < 0) { |
| 1857 __xmlIOErr(XML_FROM_FTP, 0, "send failed"); |
| 1858 closesocket(ctxt->dataFd); ctxt->dataFd = INVALID_SOCKET; |
| 1859 return INVALID_SOCKET; |
| 1860 } |
| 1861 res = xmlNanoFTPReadResponse(ctxt); |
| 1862 if (res != 2) { |
| 1863 closesocket(ctxt->dataFd); ctxt->dataFd = INVALID_SOCKET; |
| 1864 return INVALID_SOCKET; |
| 1865 } |
| 1866 if (filename == NULL) |
| 1867 snprintf(buf, sizeof(buf), "RETR %s\r\n", ctxt->path); |
| 1868 else |
| 1869 snprintf(buf, sizeof(buf), "RETR %s\r\n", filename); |
| 1870 buf[sizeof(buf) - 1] = 0; |
| 1871 len = strlen(buf); |
| 1872 #ifdef DEBUG_FTP |
| 1873 xmlGenericError(xmlGenericErrorContext, "%s", buf); |
| 1874 #endif |
| 1875 res = send(ctxt->controlFd, SEND_ARG2_CAST buf, len, 0); |
| 1876 if (res < 0) { |
| 1877 __xmlIOErr(XML_FROM_FTP, 0, "send failed"); |
| 1878 closesocket(ctxt->dataFd); ctxt->dataFd = INVALID_SOCKET; |
| 1879 return INVALID_SOCKET; |
| 1880 } |
| 1881 res = xmlNanoFTPReadResponse(ctxt); |
| 1882 if (res != 1) { |
| 1883 closesocket(ctxt->dataFd); ctxt->dataFd = INVALID_SOCKET; |
| 1884 return INVALID_SOCKET; |
| 1885 } |
| 1886 return(ctxt->dataFd); |
| 1887 } |
| 1888 |
| 1889 /** |
| 1890 * xmlNanoFTPGet: |
| 1891 * @ctx: an FTP context |
| 1892 * @callback: the user callback |
| 1893 * @userData: the user callback data |
| 1894 * @filename: the file to retrieve |
| 1895 * |
| 1896 * Fetch the given file from the server. All data are passed back |
| 1897 * in the callbacks. The last callback has a size of 0 block. |
| 1898 * |
| 1899 * Returns -1 incase of error, 0 otherwise |
| 1900 */ |
| 1901 |
| 1902 int |
| 1903 xmlNanoFTPGet(void *ctx, ftpDataCallback callback, void *userData, |
| 1904 const char *filename) { |
| 1905 xmlNanoFTPCtxtPtr ctxt = (xmlNanoFTPCtxtPtr) ctx; |
| 1906 char buf[4096]; |
| 1907 int len = 0, res; |
| 1908 fd_set rfd; |
| 1909 struct timeval tv; |
| 1910 |
| 1911 if (ctxt == NULL) return(-1); |
| 1912 if ((filename == NULL) && (ctxt->path == NULL)) |
| 1913 return(-1); |
| 1914 if (callback == NULL) |
| 1915 return(-1); |
| 1916 if (xmlNanoFTPGetSocket(ctxt, filename) == INVALID_SOCKET) |
| 1917 return(-1); |
| 1918 |
| 1919 do { |
| 1920 tv.tv_sec = 1; |
| 1921 tv.tv_usec = 0; |
| 1922 FD_ZERO(&rfd); |
| 1923 FD_SET(ctxt->dataFd, &rfd); |
| 1924 res = select(ctxt->dataFd + 1, &rfd, NULL, NULL, &tv); |
| 1925 if (res < 0) { |
| 1926 #ifdef DEBUG_FTP |
| 1927 perror("select"); |
| 1928 #endif |
| 1929 closesocket(ctxt->dataFd); ctxt->dataFd = INVALID_SOCKET; |
| 1930 return(-1); |
| 1931 } |
| 1932 if (res == 0) { |
| 1933 res = xmlNanoFTPCheckResponse(ctxt); |
| 1934 if (res < 0) { |
| 1935 closesocket(ctxt->dataFd); ctxt->dataFd = INVALID_SOCKET; |
| 1936 ctxt->dataFd = INVALID_SOCKET; |
| 1937 return(-1); |
| 1938 } |
| 1939 if (res == 2) { |
| 1940 closesocket(ctxt->dataFd); ctxt->dataFd = INVALID_SOCKET; |
| 1941 return(0); |
| 1942 } |
| 1943 |
| 1944 continue; |
| 1945 } |
| 1946 if ((len = recv(ctxt->dataFd, buf, sizeof(buf), 0)) < 0) { |
| 1947 __xmlIOErr(XML_FROM_FTP, 0, "recv failed"); |
| 1948 callback(userData, buf, len); |
| 1949 closesocket(ctxt->dataFd); ctxt->dataFd = INVALID_SOCKET; |
| 1950 return(-1); |
| 1951 } |
| 1952 callback(userData, buf, len); |
| 1953 } while (len != 0); |
| 1954 |
| 1955 return(xmlNanoFTPCloseConnection(ctxt)); |
| 1956 } |
| 1957 |
| 1958 /** |
| 1959 * xmlNanoFTPRead: |
| 1960 * @ctx: the FTP context |
| 1961 * @dest: a buffer |
| 1962 * @len: the buffer length |
| 1963 * |
| 1964 * This function tries to read @len bytes from the existing FTP connection |
| 1965 * and saves them in @dest. This is a blocking call. |
| 1966 * |
| 1967 * Returns the number of byte read. 0 is an indication of an end of connection. |
| 1968 * -1 indicates a parameter error. |
| 1969 */ |
| 1970 int |
| 1971 xmlNanoFTPRead(void *ctx, void *dest, int len) { |
| 1972 xmlNanoFTPCtxtPtr ctxt = (xmlNanoFTPCtxtPtr) ctx; |
| 1973 |
| 1974 if (ctx == NULL) return(-1); |
| 1975 if (ctxt->dataFd == INVALID_SOCKET) return(0); |
| 1976 if (dest == NULL) return(-1); |
| 1977 if (len <= 0) return(0); |
| 1978 |
| 1979 len = recv(ctxt->dataFd, dest, len, 0); |
| 1980 if (len <= 0) { |
| 1981 if (len < 0) |
| 1982 __xmlIOErr(XML_FROM_FTP, 0, "recv failed"); |
| 1983 xmlNanoFTPCloseConnection(ctxt); |
| 1984 } |
| 1985 #ifdef DEBUG_FTP |
| 1986 xmlGenericError(xmlGenericErrorContext, "Recvd %d bytes\n", len); |
| 1987 #endif |
| 1988 return(len); |
| 1989 } |
| 1990 |
| 1991 /** |
| 1992 * xmlNanoFTPOpen: |
| 1993 * @URL: the URL to the resource |
| 1994 * |
| 1995 * Start to fetch the given ftp:// resource |
| 1996 * |
| 1997 * Returns an FTP context, or NULL |
| 1998 */ |
| 1999 |
| 2000 void* |
| 2001 xmlNanoFTPOpen(const char *URL) { |
| 2002 xmlNanoFTPCtxtPtr ctxt; |
| 2003 SOCKET sock; |
| 2004 |
| 2005 xmlNanoFTPInit(); |
| 2006 if (URL == NULL) return(NULL); |
| 2007 if (strncmp("ftp://", URL, 6)) return(NULL); |
| 2008 |
| 2009 ctxt = (xmlNanoFTPCtxtPtr) xmlNanoFTPNewCtxt(URL); |
| 2010 if (ctxt == NULL) return(NULL); |
| 2011 if (xmlNanoFTPConnect(ctxt) < 0) { |
| 2012 xmlNanoFTPFreeCtxt(ctxt); |
| 2013 return(NULL); |
| 2014 } |
| 2015 sock = xmlNanoFTPGetSocket(ctxt, ctxt->path); |
| 2016 if (sock == INVALID_SOCKET) { |
| 2017 xmlNanoFTPFreeCtxt(ctxt); |
| 2018 return(NULL); |
| 2019 } |
| 2020 return(ctxt); |
| 2021 } |
| 2022 |
| 2023 /** |
| 2024 * xmlNanoFTPClose: |
| 2025 * @ctx: an FTP context |
| 2026 * |
| 2027 * Close the connection and both control and transport |
| 2028 * |
| 2029 * Returns -1 incase of error, 0 otherwise |
| 2030 */ |
| 2031 |
| 2032 int |
| 2033 xmlNanoFTPClose(void *ctx) { |
| 2034 xmlNanoFTPCtxtPtr ctxt = (xmlNanoFTPCtxtPtr) ctx; |
| 2035 |
| 2036 if (ctxt == NULL) |
| 2037 return(-1); |
| 2038 |
| 2039 if (ctxt->dataFd != INVALID_SOCKET) { |
| 2040 closesocket(ctxt->dataFd); |
| 2041 ctxt->dataFd = INVALID_SOCKET; |
| 2042 } |
| 2043 if (ctxt->controlFd != INVALID_SOCKET) { |
| 2044 xmlNanoFTPQuit(ctxt); |
| 2045 closesocket(ctxt->controlFd); |
| 2046 ctxt->controlFd = INVALID_SOCKET; |
| 2047 } |
| 2048 xmlNanoFTPFreeCtxt(ctxt); |
| 2049 return(0); |
| 2050 } |
| 2051 |
| 2052 #ifdef STANDALONE |
| 2053 /************************************************************************ |
| 2054 * * |
| 2055 * Basic test in Standalone mode * |
| 2056 * * |
| 2057 ************************************************************************/ |
| 2058 static |
| 2059 void ftpList(void *userData, const char *filename, const char* attrib, |
| 2060 const char *owner, const char *group, unsigned long size, int links
, |
| 2061 int year, const char *month, int day, int hour, int minute) { |
| 2062 xmlGenericError(xmlGenericErrorContext, |
| 2063 "%s %s %s %ld %s\n", attrib, owner, group, size, filename); |
| 2064 } |
| 2065 static |
| 2066 void ftpData(void *userData, const char *data, int len) { |
| 2067 if (userData == NULL) return; |
| 2068 if (len <= 0) { |
| 2069 fclose((FILE*)userData); |
| 2070 return; |
| 2071 } |
| 2072 fwrite(data, len, 1, (FILE*)userData); |
| 2073 } |
| 2074 |
| 2075 int main(int argc, char **argv) { |
| 2076 void *ctxt; |
| 2077 FILE *output; |
| 2078 char *tstfile = NULL; |
| 2079 |
| 2080 xmlNanoFTPInit(); |
| 2081 if (argc > 1) { |
| 2082 ctxt = xmlNanoFTPNewCtxt(argv[1]); |
| 2083 if (xmlNanoFTPConnect(ctxt) < 0) { |
| 2084 xmlGenericError(xmlGenericErrorContext, |
| 2085 "Couldn't connect to %s\n", argv[1]); |
| 2086 exit(1); |
| 2087 } |
| 2088 if (argc > 2) |
| 2089 tstfile = argv[2]; |
| 2090 } else |
| 2091 ctxt = xmlNanoFTPConnectTo("localhost", 0); |
| 2092 if (ctxt == NULL) { |
| 2093 xmlGenericError(xmlGenericErrorContext, |
| 2094 "Couldn't connect to localhost\n"); |
| 2095 exit(1); |
| 2096 } |
| 2097 xmlNanoFTPList(ctxt, ftpList, NULL, tstfile); |
| 2098 output = fopen("/tmp/tstdata", "w"); |
| 2099 if (output != NULL) { |
| 2100 if (xmlNanoFTPGet(ctxt, ftpData, (void *) output, tstfile) < 0) |
| 2101 xmlGenericError(xmlGenericErrorContext, |
| 2102 "Failed to get file\n"); |
| 2103 |
| 2104 } |
| 2105 xmlNanoFTPClose(ctxt); |
| 2106 xmlMemoryDump(); |
| 2107 exit(0); |
| 2108 } |
| 2109 #endif /* STANDALONE */ |
| 2110 #else /* !LIBXML_FTP_ENABLED */ |
| 2111 #ifdef STANDALONE |
| 2112 #include <stdio.h> |
| 2113 int main(int argc, char **argv) { |
| 2114 xmlGenericError(xmlGenericErrorContext, |
| 2115 "%s : FTP support not compiled in\n", argv[0]); |
| 2116 return(0); |
| 2117 } |
| 2118 #endif /* STANDALONE */ |
| 2119 #endif /* LIBXML_FTP_ENABLED */ |
| 2120 #define bottom_nanoftp |
| 2121 #include "elfgcchack.h" |
| OLD | NEW |
|---|
Chromium Code Reviews
Issue 1193533007:
Upgrade to libxml 2.9.2 and libxslt 1.1.28 (Closed)
Base URL: https://chromium.googlesource.com/chromium/src.git@master