boost::shared_ptr< Base<EncodingT> > IDiaEnumLineNumbersPtrInterpreter<EncodingT>::next(const boost::shared_ptr< Base<EncodingT> >& celt, boost::shared_ptr< Base<EncodingT> >& rgelt, boost::shared_ptr< Base<EncodingT> >& pceltFetched) { boost::shared_ptr< Base<EncodingT> > res(new Numeric<EncodingT>()); unsigned long nativeCelt; IDiaLineNumberPtr nativeRgelt; unsigned long nativePceltFetched; if (check_numeric(celt, nativeCelt) && check_IDiaLineNumberPtr(rgelt, nativeRgelt) && check_numeric(pceltFetched, nativePceltFetched)) { res.reset(new Numeric<EncodingT>(value()->Next(nativeCelt, &nativeRgelt, &nativePceltFetched))); reset_IDiaLineNumberPtr(rgelt, nativeRgelt); reset_numeric(pceltFetched, nativePceltFetched); } return res; }
void CppEnumInterpreterAccess<EncodingT>::fillOneCppEnumConstant(boost::shared_ptr< Base<EncodingT> >& refCppEnum, const boost::shared_ptr< Base<EncodingT> >& identifier, const boost::shared_ptr< Base<EncodingT> >& nowait) { clearError(); try { bool nativeNoWait; boost::shared_ptr< _CppEnum<EncodingT> > nativeRefCppEnum; int nativeIdentifier; if (check_cppEnum(refCppEnum, nativeRefCppEnum) && check_numeric(identifier, nativeIdentifier) && check_bool(nowait, nativeNoWait)) { m_object->fillOneCppEnumConstant(nativeRefCppEnum, nativeIdentifier, nativeNoWait); reset_cppEnum(refCppEnum, nativeRefCppEnum); } } catch (std::exception& e) { setError(e); } }
void CppClassInterpreter<EncodingT>::setLinesCount(boost::shared_ptr< Base<EncodingT> > const& linesCount) { int nativeLinesCount; if (check_numeric(linesCount, nativeLinesCount)) { getValue()->setLinesCount(nativeLinesCount); } }
void CppClassInterpreter<EncodingT>::setIsAbstract(boost::shared_ptr< Base<EncodingT> > const& isAbstract) { int nativeIsAbstract; if (check_numeric(isAbstract, nativeIsAbstract)) { getValue()->setIsAbstract(nativeIsAbstract); } }
void CppClassInterpreter<EncodingT>::removeCppAttribute(boost::shared_ptr< Base<EncodingT> > const& n) { int nativePosition; if (check_numeric(n, nativePosition)) { getValue()->eraseCppAttribute(getValue()->getCppAttributesBeginning()+nativePosition); } }
void CppAttributeInterpreter<EncodingT>::setIsStatic(boost::shared_ptr< Base<EncodingT> > const& isStatic) { int nativeIsStatic; if (check_numeric(isStatic, nativeIsStatic)) { getValue()->setIsStatic(nativeIsStatic); } }
void CppEnumConstantInterpreter<EncodingT>::setDefaultValue(boost::shared_ptr< Base<EncodingT> > const& defaultValue) { int nativeDefaultValue; if (check_numeric(defaultValue, nativeDefaultValue)) { getValue()->setDefaultValue(nativeDefaultValue); } }
void CppEnumConstantInterpreter<EncodingT>::setStartBlock(boost::shared_ptr< Base<EncodingT> > const& startBlock) { int nativeStartBlock; if (check_numeric(startBlock, nativeStartBlock)) { getValue()->setStartBlock(nativeStartBlock); } }
void CppAttributeInterpreter<EncodingT>::setIsConst(boost::shared_ptr< Base<EncodingT> > const& isConst) { int nativeIsConst; if (check_numeric(isConst, nativeIsConst)) { getValue()->setIsConst(nativeIsConst); } }
void CppAttributeInterpreter<EncodingT>::setLineNumber(boost::shared_ptr< Base<EncodingT> > const& lineNumber) { int nativeLineNumber; if (check_numeric(lineNumber, nativeLineNumber)) { getValue()->setLineNumber(nativeLineNumber); } }
boost::shared_ptr< Base<EncodingT> > IDiaSourceFilePtrInterpreter<EncodingT>::get_checksum(boost::shared_ptr< Base<EncodingT> >& cbData, boost::shared_ptr< Base<EncodingT> >& pcbData, boost::shared_ptr< Base<EncodingT> >& data) { boost::shared_ptr< Base<EncodingT> > res(new Numeric<EncodingT>()); unsigned long nativeCbData; unsigned long nativePcbData; std::vector< unsigned char > nativeData; if (check_numeric(cbData, nativeCbData) && check_numeric(pcbData, nativePcbData) && check_array(data, nativeData, check_numeric<EncodingT, unsigned char>)) { res.reset(new Numeric<EncodingT>(value()->get_checksum(nativeCbData, &nativePcbData, nativeData.data()))); reset_numeric(cbData, nativeCbData); reset_numeric(pcbData, nativePcbData); reset_array(data, nativeData, reset_numeric<EncodingT, unsigned char>); } return res; }
void CppClassInterpreter<EncodingT>::setIsInterface(boost::shared_ptr< Base<EncodingT> > const& isInterface) { int nativeIsInterface; if (check_numeric(isInterface, nativeIsInterface)) { getValue()->setIsInterface(nativeIsInterface); } }
void CppAttributeInterpreter<EncodingT>::setLengthBlock(boost::shared_ptr< Base<EncodingT> > const& lengthBlock) { int nativeLengthBlock; if (check_numeric(lengthBlock, nativeLengthBlock)) { getValue()->setLengthBlock(nativeLengthBlock); } }
//disgusting function because they can't seem to use a standard //date format... void reformat_date(const char * src, char * dest) { if (src == NULL) return; std::size_t len = std::strlen(src); std::size_t offset = 0; if (len < 8 || len > 10) { throw parse_error("invalid date format"); } check_numeric(src[0]); if (src[1] == '-') { offset = 2; dest[8] = '0'; dest[9] = src[0]; } else { offset = 3; check_numeric(src[1]); check_dash(src[2]); dest[8] = src[0]; dest[9] = src[1]; } dest[7] = '-'; check_numeric(src[offset]); if (src[offset+1] == '-') { dest[5] = '0'; dest[6] = src[offset]; offset += 2; } else { check_numeric(src[offset+1]); check_dash(src[offset+2]); dest[5] = src[offset]; dest[6] = src[offset+1]; offset += 3; } dest[4] = '-'; if (len - offset != 4) { throw parse_error("invalid date format"); } for (int i = 0; i < 4; ++i) { check_numeric(src[offset+i]); dest[i] = src[offset+i]; } dest[10] = '\0'; //DONE! }
static int get_passive_sock(UrlResource *rsrc, int control) { unsigned char *addr; struct sockaddr_in sa; int sock; int x; char *line, *orig_line; send_control(control, "PASV\r\n", NULL); if( !((line = get_line(rsrc, control)) && check_numeric("227", line)) ) { nvfree(line); return 0; } orig_line = line; if (strlen(line) < 4) { nvfree(line); return 0; } if (!(sock = sock_init(rsrc->op, &sa, control))) return -1; /* skip the numeric response */ line += 4; /* then find the digits */ while (!(isdigit(*line))) line++; /* ugliness from snarf 1.x */ sa.sin_family = AF_INET; addr = (unsigned char *)&sa.sin_addr; for(x = 0; x < 4; x++) { addr[x] = atoi(line); line = strchr(line,',') + 1; } addr = (unsigned char *)&sa.sin_port ; addr[0] = atoi(line); line = strchr(line,',') + 1; addr[1] = atoi(line); if (connect(sock, (struct sockaddr *)&sa, sizeof(sa)) < 0) { nvfree(orig_line); ui_error(rsrc->op, "unable to connect (%s)", strerror(errno)); return -1; } nvfree(orig_line); return sock; } /* get_passive_sock() */
void CppClassInterpreter<EncodingT>::insertCppAttribute(boost::shared_ptr< Base<EncodingT> > const& n, boost::shared_ptr< Base<EncodingT> > const& cppAttribute) { int nativePosition; boost::shared_ptr< _CppAttribute<EncodingT> > nativeCppAttribute; if (check_numeric(n, nativePosition) && check_cppAttribute(cppAttribute, nativeCppAttribute)) { getValue()->insertCppAttribute(getValue()->getCppAttributesBeginning()+nativePosition, nativeCppAttribute); } }
boost::shared_ptr< Base<EncodingT> > CppClassInterpreter<EncodingT>::getCppAttribute(boost::shared_ptr< Base<EncodingT> > const& n) { boost::shared_ptr< Base<EncodingT> > res(new CppAttributeInterpreter<EncodingT>()); int nativePosition; if (check_numeric(n, nativePosition)) { res.reset(new CppAttributeInterpreter<EncodingT>(getValue()->getCppAttributeAt(nativePosition))); } return res; }
boost::shared_ptr< Base<EncodingT> > IDiaEnumLineNumbersPtrInterpreter<EncodingT>::skip(const boost::shared_ptr< Base<EncodingT> >& celt) { boost::shared_ptr< Base<EncodingT> > res(new Numeric<EncodingT>()); unsigned long nativeCelt; if (check_numeric(celt, nativeCelt)) { res.reset(new Numeric<EncodingT>(value()->Skip(nativeCelt))); } return res; }
boost::shared_ptr< Base<EncodingT> > IDiaEnumLineNumbersPtrInterpreter<EncodingT>::get_Count(boost::shared_ptr< Base<EncodingT> >& pRetVal) { boost::shared_ptr< Base<EncodingT> > res(new Numeric<EncodingT>()); long nativePRetVal; if (check_numeric(pRetVal, nativePRetVal)) { res.reset(new Numeric<EncodingT>(value()->get_Count(&nativePRetVal))); reset_numeric(pRetVal, nativePRetVal); } return res; }
CppEnumConstantInterpreter<EncodingT>::CppEnumConstantInterpreter(boost::shared_ptr< Base<EncodingT> > const& name, boost::shared_ptr< Base<EncodingT> > const& defaultValue, boost::shared_ptr< Base<EncodingT> > const& startBlock, boost::shared_ptr< Base<EncodingT> > const& lengthBlock) { typename EncodingT::string_t nativeName; int nativeDefaultValue; int nativeStartBlock; int nativeLengthBlock; if (check_string<EncodingT>(name, nativeName) && check_numeric(defaultValue, nativeDefaultValue) && check_numeric(startBlock, nativeStartBlock) && check_numeric(lengthBlock, nativeLengthBlock)) { setValue(boost::shared_ptr< _CppEnumConstant<EncodingT> >(new _CppEnumConstant<EncodingT>(nativeName, nativeDefaultValue, nativeStartBlock, nativeLengthBlock))); } }
CppAttributeInterpreter<EncodingT>::CppAttributeInterpreter(boost::shared_ptr< Base<EncodingT> > const& attrType, boost::shared_ptr< Base<EncodingT> > const& name, boost::shared_ptr< Base<EncodingT> > const& accessSpecifier, boost::shared_ptr< Base<EncodingT> > const& isStatic, boost::shared_ptr< Base<EncodingT> > const& isConst, boost::shared_ptr< Base<EncodingT> > const& constValue, boost::shared_ptr< Base<EncodingT> > const& lineNumber, boost::shared_ptr< Base<EncodingT> > const& startBlock, boost::shared_ptr< Base<EncodingT> > const& lengthBlock) { typename EncodingT::string_t nativeAttrType; typename EncodingT::string_t nativeName; typename EncodingT::string_t nativeAccessSpecifier; int nativeIsStatic; int nativeIsConst; typename EncodingT::string_t nativeConstValue; int nativeLineNumber; int nativeStartBlock; int nativeLengthBlock; if (check_string<EncodingT>(attrType, nativeAttrType) && check_string<EncodingT>(name, nativeName) && check_string<EncodingT>(accessSpecifier, nativeAccessSpecifier) && check_numeric(isStatic, nativeIsStatic) && check_numeric(isConst, nativeIsConst) && check_string<EncodingT>(constValue, nativeConstValue) && check_numeric(lineNumber, nativeLineNumber) && check_numeric(startBlock, nativeStartBlock) && check_numeric(lengthBlock, nativeLengthBlock)) { setValue(boost::shared_ptr< _CppAttribute<EncodingT> >(new _CppAttribute<EncodingT>(nativeAttrType, nativeName, nativeAccessSpecifier, nativeIsStatic, nativeIsConst, nativeConstValue, nativeLineNumber, nativeStartBlock, nativeLengthBlock))); } }
boost::shared_ptr< Base<EncodingT> > IDiaEnumLineNumbersPtrInterpreter<EncodingT>::item(const boost::shared_ptr< Base<EncodingT> >& index, boost::shared_ptr< Base<EncodingT> >& symbol) { boost::shared_ptr< Base<EncodingT> > res(new Numeric<EncodingT>()); long nativeIndex; IDiaLineNumberPtr nativeSymbol; if (check_numeric(index, nativeIndex) && check_IDiaLineNumberPtr(symbol, nativeSymbol)) { res.reset(new Numeric<EncodingT>(value()->Item(nativeIndex, &nativeSymbol))); reset_IDiaLineNumberPtr(symbol, nativeSymbol); } return res; }
int get_sock(UrlResource *rsrc, int control) { struct sockaddr_in sa; unsigned char *addr; unsigned char *port; char *line; char port_string[BUFSIZE]; int sock; socklen_t i; if ( (sock = sock_init(&sa, control)) < 0 ) return -1; if ( S_LISTEN(sock, 0) < 0 ) { S_CLOSE(sock); LIBNET_DEBUG("listen"); return -1; } i = sizeof(sa); S_GETSOCKNAME(sock, (struct sockaddr *)&sa, &i); addr = (unsigned char *)(&sa.sin_addr.s_addr); port = (unsigned char *)(&sa.sin_port); sprintf(port_string, "PORT %d,%d,%d,%d,%d,%d\r\n", addr[0], addr[1], addr[2], addr[3], port[0], (unsigned char)port[1]); send_control(control, port_string, NULL); if ( !((line = get_line(rsrc, control)) && check_numeric("200", line)) ) { safe_free(line); S_CLOSE(sock); return -1; } safe_free(line); return sock; }
boost::shared_ptr< Base<EncodingT> > CppEnumInterpreterAccess<EncodingT>::getOneCppEnum(boost::shared_ptr< Base<EncodingT> > const& identifier) { boost::shared_ptr< Base<EncodingT> > res(new CppEnumInterpreter<EncodingT>()); clearError(); try { int nativeIdentifier; if (check_numeric(identifier, nativeIdentifier)) { res.reset(new CppEnumInterpreter<EncodingT>(m_object->getOneCppEnum(nativeIdentifier))); } } catch (std::exception& e) { setError(e); } return res; }
static int get_sock(UrlResource *rsrc, int control) { struct sockaddr_in sa; unsigned char *addr; unsigned char *port; char *line; char port_string[SNARF_BUFSIZE]; unsigned int sock; socklen_t i; if (!(sock = sock_init(rsrc->op, &sa, control))) return 0; if (listen(sock, 0) < 0) { ui_error(rsrc->op, "unable to listen (%s)", strerror(errno)); return 0; } i = sizeof(sa); getsockname(sock, (struct sockaddr *)&sa, &i); addr = (unsigned char *)(&sa.sin_addr.s_addr); port = (unsigned char *)(&sa.sin_port); sprintf(port_string, "PORT %d,%d,%d,%d,%d,%d\r\n", addr[0], addr[1], addr[2], addr[3], port[0],(unsigned char)port[1]); send_control(control, port_string, NULL); if (!((line = get_line(rsrc, control)) && check_numeric("200", line))) { nvfree(line); return 0; } nvfree(line); return sock; } /* get_sock() */
boost::shared_ptr< Base<EncodingT> > CppEnumInterpreterAccess<EncodingT>::selectOneCppEnum(boost::shared_ptr< Base<EncodingT> > const& identifier, const boost::shared_ptr< Base<EncodingT> >& nowait) { boost::shared_ptr< Base<EncodingT> > res(new CppEnumInterpreter<EncodingT>()); clearError(); try { bool nativeNoWait; int nativeIdentifier; if (check_numeric(identifier, nativeIdentifier) && check_bool(nowait, nativeNoWait)) { res.reset(new CppEnumInterpreter<EncodingT>(m_object->selectOneCppEnum(nativeIdentifier, nativeNoWait))); } } catch (std::exception& e) { setError(e); } return res; }
CppClassInterpreter<EncodingT>::CppClassInterpreter(boost::shared_ptr< Base<EncodingT> > const& name, boost::shared_ptr< Base<EncodingT> > const& isStruct, boost::shared_ptr< Base<EncodingT> > const& isInterface, boost::shared_ptr< Base<EncodingT> > const& isAbstract, boost::shared_ptr< Base<EncodingT> > const& linesCount, boost::shared_ptr< Base<EncodingT> > const& lineNumber, boost::shared_ptr< Base<EncodingT> > const& startBlock, boost::shared_ptr< Base<EncodingT> > const& lengthBlock) { typename EncodingT::string_t nativeName; int nativeIsStruct; int nativeIsInterface; int nativeIsAbstract; int nativeLinesCount; int nativeLineNumber; int nativeStartBlock; int nativeLengthBlock; if (check_string<EncodingT>(name, nativeName) && check_numeric(isStruct, nativeIsStruct) && check_numeric(isInterface, nativeIsInterface) && check_numeric(isAbstract, nativeIsAbstract) && check_numeric(linesCount, nativeLinesCount) && check_numeric(lineNumber, nativeLineNumber) && check_numeric(startBlock, nativeStartBlock) && check_numeric(lengthBlock, nativeLengthBlock)) { setValue(boost::shared_ptr< _CppClass<EncodingT> >(new _CppClass<EncodingT>(nativeName, nativeIsStruct, nativeIsInterface, nativeIsAbstract, nativeLinesCount, nativeLineNumber, nativeStartBlock, nativeLengthBlock))); } }
int ftp_transfer(UrlResource *rsrc, libnet_callback notify) { Url *u = NULL; FILE *out = NULL; char *line = NULL; int sock = -1; int data_sock = -1; int passive = 1; int retval = 0; int msg_code = 0; u = rsrc->url; /* first of all, if this is proxied, just pass it off to the http module, since that's how we support proxying. */ rsrc->proxy = get_proxy("FTP_PROXY"); if ( rsrc->proxy ) { return http_transfer(rsrc, notify); } ftp_set_defaults(rsrc, u); sock = util_tcp_connect(u->host, u->port); if (sock < 0) { if (rsrc->running) { notify(NET_MSG_DOWNLOAD_FINISH, (UINT32)-NET_ERR_CONNECT_FAILED); } //S_CLOSE(sock); return 0; } if ( !(line = get_line(rsrc, sock)) ) { if (rsrc->running) { notify(NET_MSG_DOWNLOAD_FINISH, (UINT32)-NET_ERR_FTP_SERVER_ERROR); } S_CLOSE(sock); return 0; } if ( !check_numeric("220", line) ) { safe_free(line); S_CLOSE(sock); LIBNET_DEBUG("bad server greeting"); if (rsrc->running) { notify(NET_MSG_DOWNLOAD_FINISH, (UINT32)-NET_ERR_FTP_SERVER_ERROR); } return 0; } safe_free(line); send_control(sock, "USER ", u->username, "\r\n", NULL); if ( !(line = get_line(rsrc, sock)) ) { msg_code = -NET_ERR_LOGIN_FAILED; goto cleanup; } /* do the password dance */ if ( !check_numeric("230", line) ) { if ( !check_numeric("331", line)) { safe_free(line); LIBNET_DEBUG("bad/unexpected response: %s", line); msg_code = -NET_ERR_LOGIN_FAILED; goto cleanup; } else { safe_free(line); send_control(sock, "PASS ", u->password, "\r\n", NULL); if ( !((line = get_line(rsrc, sock)) && check_numeric("230", line)) ) { safe_free(line); LIBNET_DEBUG("login failed"); msg_code = -NET_ERR_LOGIN_FAILED; goto cleanup; } //safe_free(line); } } safe_free(line); /* set binmode */ send_control(sock, "TYPE I\r\n", NULL); if ( !(line = get_line(rsrc, sock)) ) { msg_code = -NET_ERR_FTP_SERVER_ERROR; goto cleanup; } safe_free(line); #if 1 // user can't change ftp path to "/" if server don't support it if ( u->path && (STRCMP(u->path, "/") != 0)) { /* CWD using relative path */ char *relative_path = u->path[0] == '/' ? &u->path[1] : &u->path[0]; send_control(sock, "CWD ", relative_path, "\r\n", NULL); if ( !((line = get_line(rsrc, sock)) && check_numeric("250", line)) ) { safe_free(line); msg_code = -NET_ERR_OPERATION_NOT_PERMIT; goto cleanup; } safe_free(line); } #endif /* finally, the good stuff */ /* get a socket for reading. try passive first. */ if ( ! (rsrc->options & OPT_ACTIVE) ) { if ( (data_sock = get_passive_sock(rsrc, sock)) < 0 ) { msg_code = -NET_ERR_CONNECT_FAILED; goto cleanup; } } if ( data_sock < 0 ) { if ( (data_sock = get_sock(rsrc, sock)) < 1 ) { msg_code = -NET_ERR_CONNECT_FAILED; goto cleanup; } else passive = 0; } if (u->file) { send_control(sock, "SIZE ", u->file, "\r\n", NULL); line = get_line(rsrc, sock); if (line && check_numeric("213", line)) { rsrc->outfile_size = ATOI(line + 4); } else if (line && check_numeric("550", line)) { safe_free(line); msg_code = -NET_ERR_FILE_NOT_FOUND; goto cleanup; } else { rsrc->outfile_size = 0; } if (line) FREE(line); } /* handle resume */ if ( rsrc->outfile_offset && (rsrc->options & OPT_RESUME) ) { char numstring[32]; /* ugly hack */ sprintf(numstring, "%ld", (long int )rsrc->outfile_offset); send_control(sock, "REST ", numstring, "\r\n", NULL); if ( !((line = get_line(rsrc, sock)) && check_numeric("350", line)) ) { safe_free(line); LIBNET_DEBUG("server does not support FTP resume, try again without -r"); msg_code = -NET_ERR_OPERATION_NOT_PERMIT; goto cleanup; } safe_free(line); } if (u->file) send_control(sock, "RETR ", u->file, "\r\n", NULL); else send_control(sock, "NLST\r\n", NULL); if ( !((line = get_line(rsrc, sock)) && (check_numeric("150", line) || check_numeric("125", line))) ) { safe_free(line); msg_code = -NET_ERR_OPERATION_NOT_PERMIT; goto cleanup; } LIBNET_DEBUG("ftp reply(RETR): %s\n", line); if ( !passive ) data_sock = S_ACCEPT(data_sock, NULL, NULL); /* rsrc->outfile_size = guess_file_size(line); */ safe_free(line); if (rsrc->outfile) { if (get_file_size(rsrc->outfile) > 0) out = fopen(rsrc->outfile, "rb+"); else out = fopen(rsrc->outfile, "wb"); if ( !out ) { //report(ERR, "opening %s: %s", rsrc->outfile, // strerror(errno)); msg_code = -NET_ERR_FILE_SAVE_ERROR; goto cleanup; } } retval = dump_data(rsrc, data_sock, out, notify); if (rsrc->running) { line = get_line(rsrc, sock); /* 226 Transfer complete */ LIBNET_DEBUG("ftp(done): %s\n", line); safe_free(line); } cleanup: send_control(sock, "QUIT\r\n", NULL); line = get_line(rsrc, sock); /* 221 Goodbye */ LIBNET_DEBUG("ftp(QUIT): %s\n", line); safe_free(line); if (out) fclose(out); if (data_sock >= 0) { S_CLOSE(data_sock); } if (sock >= 0) { S_CLOSE(sock); } #ifndef WIN32 if (rsrc->outfile) fs_sync(rsrc->outfile); #endif if (msg_code < 0 && rsrc->running) { notify(NET_MSG_DOWNLOAD_FINISH, (UINT32)msg_code); } return retval; }
int get_passive_sock(UrlResource *rsrc, int control) { unsigned char *addr; struct sockaddr_in sa; int sock; int x; char *line, *orig_line; send_control(control, "PASV\r\n", NULL); if ( !((line = get_line(rsrc, control)) && check_numeric("227", line)) ) { safe_free(line); return -1; } orig_line = line; if ( strlen(line) < 4 ) { safe_free(line); return -1; } if ( (sock = sock_init(&sa, control)) < 0 ) { safe_free(orig_line); return -1; } /* skip the numeric response */ line += 4; /* then find the digits */ while ( !(isdigit(*line)) ) line++; sa.sin_family = AF_INET; addr = (unsigned char *) & sa.sin_addr; for (x = 0; x < 4; x++) { addr[x] = ATOI(line); line = strchr(line, ',') + 1; } addr = (unsigned char *) & sa.sin_port ; addr[0] = ATOI(line); line = strchr(line, ',') + 1; addr[1] = ATOI(line); if ( S_CONNECT(sock, (struct sockaddr *)&sa, sizeof(sa)) < 0 ) { S_CLOSE(sock); safe_free(orig_line); LIBNET_DEBUG("connect"); return -1; } safe_free(orig_line); return sock; }
int ftp_transfer(UrlResource *rsrc) { Url *u = NULL; char *line = NULL; int sock = 0; int data_sock = 0; int passive = 1; int retval = 0; u = rsrc->url; /* * first of all, if this is proxied, just pass it off to the * http module, since that's how we support proxying. */ rsrc->proxy = get_proxy("FTP_PROXY"); if (rsrc->proxy && (rsrc->proxy[0] != '\0')) { return http_transfer(rsrc); } ftp_set_defaults(rsrc, u); if (!(sock = tcp_connect(rsrc->op, u->host, u->port))) return FALSE; if (!(line = get_line(rsrc, sock))) return FALSE; if (!check_numeric("220", line)) { ui_error(rsrc->op, "bad ftp server greeting: %s", line); nvfree(line); return FALSE; } send_control(sock, "USER ", u->username, "\r\n", NULL); if (!(line = get_line(rsrc, sock))) return FALSE; /* do the password dance */ if (!check_numeric("230", line)) { if (!check_numeric("331", line)) { ui_error(rsrc->op, "bad/unexpected response: %s", line); nvfree(line); return FALSE; } else { nvfree(line); send_control(sock, "PASS ", u->password, "\r\n", NULL); if (!((line = get_line(rsrc, sock)) && check_numeric("230", line)) ) { nvfree(line); ui_error(rsrc->op, "login failed"); return FALSE; } nvfree(line); } } /* set binmode */ send_control(sock, "TYPE I\r\n", NULL); if (!(line = get_line(rsrc, sock))) return 0; nvfree(line); if (u->path) { send_control(sock, "CWD ", u->path, "\r\n", NULL); if (!((line = get_line(rsrc, sock)) && check_numeric("250", line))) { nvfree(line); close_quit(sock); return 0; } nvfree(line); } /* finally, the good stuff */ /* get a socket for reading. try passive first. */ if ((data_sock = get_passive_sock(rsrc, sock)) == -1) { return FALSE; } if (!data_sock) { if ((data_sock = get_sock(rsrc, sock)) < 1) return 0; else passive = 0; } if (u->file) { send_control(sock, "SIZE ", u->file, "\r\n", NULL); line = get_line(rsrc, sock); if (line && check_numeric("213", line)) { rsrc->outfile_size = atoi(line + 3); } else { rsrc->outfile_size = 0; } } if (u->file) send_control(sock, "RETR ", u->file, "\r\n", NULL); else send_control(sock, "NLST\r\n", NULL); if (!((line = get_line(rsrc, sock)) && (check_numeric("150", line) || check_numeric("125", line)))) { nvfree(line); close_quit(sock); return 0; } if (!passive) data_sock = accept(data_sock, NULL, NULL); nvfree(line); retval = dump_data(rsrc, data_sock); line = get_line(rsrc, sock); /* 226 Transfer complete */ nvfree(line); send_control(sock, "QUIT\r\n", NULL); line = get_line(rsrc, sock); /* 221 Goodbye */ nvfree(line); close(sock); close(data_sock); return retval; } /* ftp_transfer() */