int main() {
/* Repeatedly save and load the context, then compare it to the first one. */
urlctx *ctx = url_init(
"http://*gooogle*\n"
"ftp://fooo\n"
"*adwords\n"
"http*//*.php");
// Yes yes, insecure mktemp. This is a unit test.
char name[] = "/tmp/bintestXXXXXX";
mktemp(name);
if (url_save_optimized(ctx, name)) fail("save failed\n");
u32 i;
urlctx *tmp;
for (i = 0; i < 20; i++) {
tmp = url_init_file(name);
if (!tmp) fail("load failed\n");
if (url_save_optimized(tmp, name)) fail("save failed\n");
url_free(tmp);
}
tmp = url_init_file(name);
if (ctxcmp(ctx, tmp)) fail("compare failed\n");
url_free(ctx);
url_free(tmp);
unlink(name);
return 0;
}
/* Full_URL is like "ftp://*****:*****@192.168.0.1/xxxx", user and password can be NULL*/
unsigned long libnet_download(char *full_url, char *outfile)
{
UrlResource *rsrc = NULL;
Url *u = NULL;
int retval = 0;
rsrc = url_resource_new();
u = url_new();
rsrc->url = url_init(u, full_url);
rsrc->options = 0;
rsrc->outfile = strdup(outfile);
rsrc->outfile_offset = 0;
rsrc->running = 1;
rsrc->options = OPT_RESUME; //default support the resume
u = rsrc->url;
if ( !rsrc->outfile && u->file )
rsrc->outfile = strdup(u->file);
if ( rsrc->outfile && (rsrc->options & OPT_RESUME))
{
rsrc->outfile_offset = get_file_size(rsrc->outfile);
if (rsrc->outfile_offset < 0)
rsrc->outfile_offset = 0;
}
create_transfer_task(rsrc, libnet_cb);
return (unsigned long)rsrc;
}
void trans_info_init(trans_info_t* info,data_list_t *list,iclock_options_t * opt,char *url,trans_help_t *trans_hep,int mode)
{
memset(info, 0, sizeof(trans_info_t));
info->file_path = NULL;
info->cache = createRamBuffer(opt->buf_size);
info->starting_time = list->last_stamp;
info->opt = opt;
info->list = list;
url_init(opt,url,info->list->table_name);
info->url = url;
info->upload_mode = mode;
info->trans_help = trans_hep;
}
/*
unsigned long libnet_download_to_pecache
branch from libnet_download_to_mem for download net work file to pe cache
use difference dump_data() when UrlResource rsrc->use_pecache != 0.
*/
unsigned long libnet_download_to_pecache(char *full_url, unsigned char* buffer, unsigned int buf_len, unsigned int offset)
{
UrlResource *rsrc = NULL;
Url *u = NULL;
int retval = 0;
if (offset >= buf_len)
{
return 0;
}
rsrc = url_resource_new();
u = url_new();
rsrc->url = url_init(u, full_url);
rsrc->options = OPT_RESUME; //default support the resume
rsrc->buffer = buffer;
rsrc->outfile_offset = offset;
rsrc->buffer_len = buf_len;
rsrc->running = 1;
rsrc->use_pecache = 1; //yuliang0604
u = rsrc->url;
if (0 == (rsrc->options & OPT_RESUME))
{
rsrc->outfile_offset = 0;
}
/* set rsrc->srcip and rsrc->srcport */
#ifdef LIB_W5300
UINT8 ip_addr[4];
char ip_str[32];
if (w5300_ioctl(0, W5300_GET_IP, ip_addr) == 0)
{
sprintf(ip_str, "%d.%d.%d.%d", ip_addr[0], ip_addr[1], ip_addr[2], ip_addr[3]);
rsrc->srcip = (char *)strdup(ip_str);
rsrc->srcport = 1024 + RAND(5000 - 1024);
LIBNET_DEBUG("w5300 tcp using: %s:%d\n", rsrc->srcip, rsrc->srcport);
}
else
{
LIBNET_DEBUG("get ip from w5300 failed!\n");
}
#endif
create_transfer_task(rsrc, libnet_cb);
return (unsigned long)rsrc;
}
/** Create a http site object.
*
* The function nth_site_create() allocates and initializes a web site
* object. A web site object can be either
* - a primary http server (@a parent is NULL),
* - a virtual http server (@a address contains hostpart), or
* - a site within a server
* (@a address does not have hostpart, only path part).
*
* @param parent pointer to parent site
* (NULL when creating a primary server object)
* @param callback pointer to callback function called when
* a request is received
* @param magic application context included in callback parameters
* @param address absolute or relative URI specifying the address of
* site
* @param tag, value, ... list of tagged parameters
*
* @TAGS
* If the @a parent is NULL, the list of tagged parameters must contain
* NTHTAG_ROOT() used to create the server engine. Tags supported when @a
* parent is NULL are NTHTAG_ROOT(), NTHTAG_MCLASS(), TPTAG_REUSE(),
* HTTPTAG_SERVER(), and HTTPTAG_SERVER_STR(). All the tags are passed to
* tport_tcreate() and tport_tbind(), too.
*
* @since Support for multiple sites was added to @VERSION_1_12_4
*/
nth_site_t *nth_site_create(nth_site_t *parent,
nth_request_f *callback,
nth_site_magic_t *magic,
url_string_t const *address,
tag_type_t tag, tag_value_t value,
...)
{
nth_site_t *site = NULL, **prev = NULL;
su_home_t home[SU_HOME_AUTO_SIZE(256)];
url_t *url, url0[1];
server_t *srv = NULL;
ta_list ta;
char *path = NULL;
size_t usize;
int is_host, is_path, wildcard = 0;
su_home_auto(home, sizeof home);
if (parent && url_is_string(address)) {
char const *s = (char const *)address;
size_t sep = strcspn(s, "/:");
if (parent->site_path) {
/* subpath */
url_init(url0, (enum url_type_e)parent->site_url->url_type);
url0->url_path = s;
address = (url_string_t*)url0;
}
else if (s[sep] == ':')
/* absolute URL with scheme */;
else if (s[sep] == '\0' && strchr(s, '.') && host_is_valid(s)) {
/* looks like a domain name */;
url_init(url0, (enum url_type_e)parent->site_url->url_type);
url0->url_host = s;
address = (url_string_t*)url0;
}
else {
/* looks like a path */
url_init(url0, (enum url_type_e)parent->site_url->url_type);
url0->url_path = s;
address = (url_string_t*)url0;
}
}
url = url_hdup(home, address->us_url);
if (!url || !callback)
return NULL;
is_host = url->url_host != NULL;
is_path = url->url_path != NULL;
if (is_host && is_path) {
SU_DEBUG_3(("nth_site_create(): virtual host and path simultanously\n"));
errno = EINVAL;
goto error;
}
if (!parent && !is_host) {
SU_DEBUG_3(("nth_site_create(): host is required\n"));
errno = EINVAL;
goto error;
}
if (parent) {
if (!parent->site_isdir) {
SU_DEBUG_3(("nth_site_create(): invalid parent resource \n"));
errno = EINVAL;
goto error;
}
srv = parent->site_server; assert(srv);
if (is_host) {
prev = site_get_host(&srv->srv_sites, url->url_host, url->url_port);
if (prev == NULL) {
SU_DEBUG_3(("nth_site_create(): host %s:%s already exists\n",
url->url_host, url->url_port ? url->url_port : ""));
errno = EEXIST;
goto error;
}
}
else {
size_t i, j;
path = (char *)url->url_path;
while (path[0] == '/')
path++;
/* Remove duplicate // */
for (i = j = 0; path[i];) {
while (path[i] == '/' && path[i + 1] == '/')
i++;
path[j++] = path[i++];
}
path[j] = path[i];
url = url0, *url = *parent->site_url;
if (url->url_path) {
url->url_path = su_strcat(home, url->url_path, path);
if (!url->url_path)
goto error;
path = (char *)url->url_path + strlen(parent->site_url->url_path);
}
else
url->url_path = path;
prev = site_get_rslot(parent, path, &path);
if (!prev || path[0] == '\0') {
SU_DEBUG_3(("nth_site_create(): directory \"%s\" already exists\n",
url->url_path));
errno = EEXIST;
goto error;
}
}
}
if (!parent) {
if (strcmp(url->url_host, "*") == 0 ||
host_cmp(url->url_host, "0.0.0.0") == 0 ||
host_cmp(url->url_host, "::") == 0)
wildcard = 1, url->url_host = "*";
}
usize = sizeof(*url) + url_xtra(url);
ta_start(ta, tag, value);
if (!parent) {
srv = server_create(url, ta_tags(ta));
prev = &srv->srv_sites;
}
if (srv && (site = su_zalloc(srv->srv_home, (sizeof *site) + usize))) {
site->site_url = (url_t *)(site + 1);
url_dup((void *)(site->site_url + 1), usize - sizeof(*url),
site->site_url, url);
assert(prev);
if ((site->site_next = *prev))
site->site_next->site_prev = &site->site_next;
*prev = site, site->site_prev = prev;
site->site_server = srv;
if (path) {
size_t path_len;
site->site_path = site->site_url->url_path + (path - url->url_path);
path_len = strlen(site->site_path); assert(path_len > 0);
if (path_len > 0 && site->site_path[path_len - 1] == '/')
path_len--, site->site_isdir = 1;
site->site_path_len = path_len;
}
else {
site->site_isdir = is_host;
site->site_path = "";
site->site_path_len = 0;
}
site->site_wildcard = wildcard;
site->site_callback = callback;
site->site_magic = magic;
if (parent)
site->site_auth = parent->site_auth;
nth_site_set_params(site, ta_tags(ta));
}
ta_end(ta);
error:
su_home_deinit(home);
return site;
}
BOOL trans_upload_file(iclock_options_t *opt,data_list_t*CurrentNode,int mode)
{
char url[1024];
char buf[1024];
char str_temp[512];
int c = -1;
int file_index;
trans_info_t info;
int fd;
char file_name[128];
int file_offset;
int read_data_len = 0;
int trans_help_fp;
BOOL ret = TRUE;
if (CurrentNode == NULL || opt == NULL) {
return TRUE;
}
chmod(BS_TRANS_HELP_FILE,0666);
trans_help_fp = open(BS_TRANS_HELP_FILE,O_RDWR|O_NONBLOCK);
file_offset = get_file_info(CurrentNode->con_type,mode,file_name);
if (trans_help_fp < 0) {
return TRUE;
}
if (file_offset < 0) {
close(trans_help_fp);
return TRUE;
}
if ((!read_file_with_offset(trans_help_fp,file_offset,(char *)&file_index,sizeof(file_index)))
|| (file_index < 0)) {
close(trans_help_fp);
return TRUE;
}
memset(&info,0,sizeof(info));
sprintf(str_temp,"gTransFlag=%s",opt->svr_trans_flag);
info.cache = createRamBuffer(opt->buf_size);
info.opt = opt;
info.list = CurrentNode;
read_file_with_offset(trans_help_fp, file_offset+sizeof(file_index),\
(char *)&info.cur_trans_log_time,sizeof(info.cur_trans_log_time));
info.starting_time = (size_t)OldEncodeTime(localtime(&info.cur_trans_log_time));
opt->con_type = CurrentNode->con_type;
url_init(opt,url,"OPERLOG");
info.url = url;
info.upload_mode = UPLOADE_MODE_QUERY;
CurrentNode->param = str_temp;
fd = open(file_name,O_RDWR|O_NONBLOCK);
if ((fd >= 0) && (file_index >= 0) && (opt->main_fun->upload_usr_read_fun != NULL)) {
if (svr_is_need_contype(opt->svr_trans_flag,CurrentNode->con_type)) {
while ((read_data_len = opt->main_fun->upload_usr_read_fun(\
CurrentNode->con_type,buf,file_index,fd)) > 0) {
c = trans_user_all_data(buf,&info,str_temp,FCT_USER);
if ( info.error != 0 || (c < 0)) {
break;
}
c = trans_user_all_data(buf,&info,str_temp,FCT_USERPIC);
if ( info.error != 0 || (c < 0)) {
break;
}
c = trans_user_all_data(buf,&info,str_temp,FCT_FACE);
if ( info.error != 0 || (c < 0)) {
break;
}
c = trans_user_all_data(buf,&info,str_temp,FCT_FINGERTMP);
if ( info.error != 0 || (c < 0)) {
break;
}
if (( info.error == 0) && (info.count == 0) && (c > 0)) {
write_file_with_offset(trans_help_fp,file_offset,(char *)&file_index,sizeof(int));
}
file_index += read_data_len;
}
if (( info.error == 0) && (info.count > 0) && (c >= 0)) {
snprintf(info.url+strlen(info.url),sizeof(url)-strlen(info.url), "%u",(unsigned int)info.starting_time);
if (cache_data_to_svr(url, &info)) {
write_file_with_offset(trans_help_fp,file_offset,(char *)&file_index,sizeof(int));
}
}
}
if (read_data_len < 1) {
file_index = -1;
write_file_with_offset(trans_help_fp,file_offset,(char *)&file_index,sizeof(int));
if (fd > 0) {
close(fd);
}
fd = open(file_name, O_RDWR|O_CREAT|O_TRUNC|O_SYNC);
}
ret = (read_data_len < 1);
} else {
ret = TRUE;
}
freeBuffer(info.cache);
if (fd >= 0) {
close(fd);
}
if (trans_help_fp >= 0) {
close(trans_help_fp);
}
return ret;
}
Static int
url_ioctl(struct ifnet *ifp, u_long cmd, caddr_t data)
{
struct url_softc *sc = ifp->if_softc;
struct ifaddr *ifa = (struct ifaddr *)data;
struct ifreq *ifr = (struct ifreq *)data;
struct mii_data *mii;
int s, error = 0;
DPRINTF(("%s: %s: enter\n", USBDEVNAME(sc->sc_dev), __func__));
if (sc->sc_dying)
return (EIO);
s = splnet();
switch (cmd) {
case SIOCSIFADDR:
ifp->if_flags |= IFF_UP;
url_init(ifp);
switch (ifa->ifa_addr->sa_family) {
#ifdef INET
case AF_INET:
arp_ifinit(&sc->sc_ac, ifa);
break;
#endif /* INET */
}
break;
case SIOCSIFMTU:
if (ifr->ifr_mtu > ETHERMTU)
error = EINVAL;
else
ifp->if_mtu = ifr->ifr_mtu;
break;
case SIOCSIFFLAGS:
if (ifp->if_flags & IFF_UP) {
if (ifp->if_flags & IFF_RUNNING &&
ifp->if_flags & IFF_PROMISC) {
URL_SETBIT2(sc, URL_RCR,
URL_RCR_AAM|URL_RCR_AAP);
} else if (ifp->if_flags & IFF_RUNNING &&
!(ifp->if_flags & IFF_PROMISC)) {
URL_CLRBIT2(sc, URL_RCR,
URL_RCR_AAM|URL_RCR_AAP);
} else if (!(ifp->if_flags & IFF_RUNNING))
url_init(ifp);
} else {
if (ifp->if_flags & IFF_RUNNING)
url_stop(ifp, 1);
}
error = 0;
break;
case SIOCADDMULTI:
case SIOCDELMULTI:
error = (cmd == SIOCADDMULTI) ?
ether_addmulti(ifr, &sc->sc_ac) :
ether_delmulti(ifr, &sc->sc_ac);
if (error == ENETRESET) {
if (ifp->if_flags & IFF_RUNNING)
url_setmulti(sc);
error = 0;
}
break;
case SIOCGIFMEDIA:
case SIOCSIFMEDIA:
mii = GET_MII(sc);
error = ifmedia_ioctl(ifp, ifr, &mii->mii_media, cmd);
break;
default:
error = EINVAL;
break;
}
splx(s);
return (error);
}
int
http_transfer(UrlResource *rsrc)
{
FILE *out = NULL;
Url *u = NULL;
Url *proxy_url = NULL;
Url *redir_u = NULL;
char *request = NULL;
char *raw_header = NULL;
HttpHeader *header = NULL;
char *len_string = NULL;
char *new_location = NULL;
char buf[BUFSIZE];
int sock = 0;
ssize_t bytes_read = 0;
int retval = 0;
int i;
/* make sure we haven't recursed too much */
if( redirect_count > REDIRECT_MAX ) {
report(ERR, "redirection max count exceeded "
"(looping redirect?)");
redirect_count = 0;
return 0;
}
/* make sure everything's initialized to something useful */
u = rsrc->url;
if( ! *(u->host) ) {
report(ERR, "no host specified");
return 0;
}
/* fill in proxyness */
if( !rsrc->proxy ) {
rsrc->proxy = get_proxy("HTTP_PROXY");
}
if( !rsrc->outfile ) {
if( u->file )
rsrc->outfile = strdup(u->file);
else
rsrc->outfile = strdup("index.html");
}
if( !u->path )
u->path = strdup("/");
if( !u->file )
u->file = strdup(""); /* funny looking */
if( !u->port )
u->port = 80;
rsrc->options |= default_opts;
/* send the request to either the proxy or the remote host */
if( rsrc->proxy ) {
proxy_url = url_new();
url_init(proxy_url, rsrc->proxy);
if( !proxy_url->port )
proxy_url->port = 80;
if( !proxy_url->host ) {
report(ERR, "bad proxy `%s'", rsrc->proxy);
return 0;
}
if( proxy_url->username )
rsrc->proxy_username = strdup(proxy_url->username);
if( proxy_url->password )
rsrc->proxy_password = strdup(proxy_url->password);
/* Prompt for proxy password if not specified */
if( proxy_url->username && !proxy_url->password ) {
char *prompt = NULL;
prompt = strconcat("Password for proxy ",
proxy_url->username, "@",
proxy_url->host, ": ", NULL);
proxy_url->password = strdup(getpass(prompt));
free(prompt);
}
if( ! (sock = tcp_connect(proxy_url->host, proxy_url->port)) )
return 0;
u->path = strdup("");
u->file = strdup(u->full_url);
request = get_request(rsrc);
write(sock, request, strlen(request));
} else /* no proxy */ {
if( ! (sock = tcp_connect(u->host, u->port)) )
return 0;
request = get_request(rsrc);
write(sock, request, strlen(request));
}
out = open_outfile(rsrc);
if( !out ) {
report(ERR, "opening %s: %s", rsrc->outfile, strerror(errno));
return 0;
}
/* check to see if it returned a HTTP 1.x response */
memset(buf, '\0', 5);
bytes_read = read(sock, buf, 8);
if( bytes_read == 0 ) {
close(sock);
return 0;
}
if( ! (buf[0] == 'H' && buf[1] == 'T'
&& buf[2] == 'T' && buf[3] == 'P') ) {
if ((rsrc->options & OPT_RESUME) &&
rsrc->outfile_offset) {
report(WARN,
"server does not support resume, "
"try again"
" with -n (no resume)");
retval = 0;
goto cleanup;
}
write(fileno(out), buf, bytes_read);
} else {
/* skip the header */
buf[bytes_read] = '\0';
raw_header = get_raw_header(sock);
raw_header = strconcat(buf, raw_header, NULL);
header = make_http_header(raw_header);
if (rsrc->options & OPT_VERBOSE) {
fwrite(raw_header, 1, strlen(raw_header), stderr);
}
/* check for redirects */
new_location = get_header_value("location", header);
if (raw_header[9] == '3' && new_location ) {
redir_u = url_new();
/* make sure we still send user/password along */
redir_u->username = safe_strdup(u->username);
redir_u->password = safe_strdup(u->password);
url_init(redir_u, new_location);
rsrc->url = redir_u;
redirect_count++;
retval = transfer(rsrc);
goto cleanup;
}
if (raw_header[9] == '4' || raw_header[9] == '5') {
for(i = 0; raw_header[i] && raw_header[i] != '\n'; i++);
raw_header[i] = '\0';
report(ERR, "HTTP error from server: %s", raw_header);
retval = 0;
goto cleanup;
}
len_string = get_header_value("content-length", header);
if (len_string)
rsrc->outfile_size = (off_t )atoi(len_string);
if (get_header_value("content-range", header))
rsrc->outfile_size += rsrc->outfile_offset;
if( (!rsrc->outfile_size) &&
(rsrc->options & OPT_RESUME) &&
!(rsrc->options & OPT_NORESUME)
&& rsrc->outfile_offset ) {
report(WARN,
"unable to determine remote file size, try again"
" with -n (no resume)");
retval = 0;
goto cleanup;
}
}
if( ! dump_data(rsrc, sock, out) )
retval = 0;
else
retval = 1;
cleanup:
free_http_header(header);
close(sock); fclose(out);
return retval;
}
static int
startline_parsereq (startline_t * dest, char *buf, char **headers)
{
char *p1;
char *p2;
char *requesturi;
int i;
dest->sipmethod = NULL;
dest->statuscode = NULL;
dest->reasonphrase = NULL;
/* The first token is the method name: */
p2 = strchr (buf, ' ');
if (p2 == NULL)
return -1;
if (p2-buf==0)
{
OSIP_TRACE (osip_trace
(__FILE__, __LINE__, OSIP_ERROR, NULL,
"No space allowed here\n"));
return -1;
}
dest->sipmethod = (char *) smalloc (p2 - buf + 1);
sstrncpy (dest->sipmethod, buf, p2 - buf);
/* The second token is a sip-url or a uri: */
p1 = strchr (p2 + 2, ' '); /* no space allowed inside sip-url */
if (p1 - p2 < 2)
return -1;
requesturi = (char *) smalloc (p1 - p2);
sstrncpy (requesturi, p2 + 1, (p1 - p2 - 1));
sclrspace (requesturi);
url_init (&(dest->rquri));
i = url_parse (dest->rquri, requesturi);
sfree (requesturi);
if (i == -1)
return -1;
/* find the the version and the beginning of headers */
{
char *hp = p1;
while ((*hp != '\r') && (*hp != '\n'))
{
if (*hp)
hp++;
else
{
OSIP_TRACE (osip_trace
(__FILE__, __LINE__, OSIP_ERROR, NULL,
"No crlf found\n"));
return -1;
}
}
if (hp - p1 < 2)
return -1;
dest->sipversion = (char *) smalloc (hp - p1);
sstrncpy (dest->sipversion, p1 + 1, (hp - p1 - 1));
hp++;
if ((*hp) && ('\r' == hp[-1]) && ('\n' == hp[0]))
hp++;
(*headers) = hp;
}
return 0;
}
int main(int argc, char* argv[])
{
if (argc != 2)
{
print_usage(argv[0]);
return EXIT_FAILURE;
}
URL url;
url_init(&url);
int error = url_from_string(&url, argv[1]);
if (error)
{
fprintf(stderr, "Could not sucessfully parse FTP url (error code: %d)\n", error);
url_destroy(&url);
return EXIT_FAILURE;
}
error = url_host_to_ip(&url);
if (error)
{
fprintf(stderr, "Could not get an IPv4 IP address from hostname %s (error code: %d)\n", url.host, error);
return EXIT_FAILURE;
}
FTP ftp;
error = ftp_connect(&ftp, url.ip, url.port ? url.port : 21);
if (error)
{
fprintf(stderr, "Could not connect to ftp at IP %s, port %d\n", url.ip, url.port ? url.port : 21);
return EXIT_FAILURE;
}
const char* user = strlen(url.user) ? url.user : "******";
const char* pass = strlen(url.password) ? url.password : "******";
error = ftp_login(&ftp, user, pass);
if (error)
{
fprintf(stderr, "Could not login with user %s and pass %s\n", user, pass);
return EXIT_FAILURE;
}
char path[1024] = "";
for (int i = 0; i < url.num_parts - 1; ++i) {
strcat(path, url.parts[i]);
strcat(path, "/");
}
if (path[0] != 0) {
error = ftp_cwd(&ftp, path);
if (error) {
perror("ftp_cwd");
return error;
}
}
error = ftp_pasv(&ftp);
if (error) {
perror("ftp_pasv");
return error;
}
const char* file_name = url.num_parts ? url.parts[url.num_parts - 1] : "";
error = ftp_retr(&ftp, file_name);
if (error) {
perror("ftp_retr");
return error;
}
error = ftp_download(&ftp, file_name);
if (error) {
perror("ftp_download");
return error;
}
error = ftp_disconnect(&ftp);
if (error) {
perror("ftp_disconnect");
return error;
}
url_destroy(&url);
return EXIT_SUCCESS;
}
int http_transfer(UrlResource *rsrc, libnet_callback notify)
{
FILE *out = NULL;
Url *u = NULL;
Url *proxy_url = NULL;
Url *redir_u = NULL;
char *request = NULL;
//char *raw_header = NULL;
HttpHeader *header = NULL;
//char *len_string = NULL;
//char *new_location = NULL;
char *tmp_string = NULL;
//char buf[BUFSIZE];
int sock = -1;
ssize_t bytes_read = 0;
int msg_code = 0;
int retval = 0;
int i;
char *buf = MALLOC(BUFSIZE);
if (!buf)
{
LIBNET_DEBUG("No enough memory!\n");
return 0;
}
/* make sure we haven't recursed too much */
if ( redirect_count > REDIRECT_MAX )
{
LIBNET_DEBUG("redirection max count exceeded (looping redirect?)");
redirect_count = 0;
msg_code = -NET_ERR_CONNECT_FAILED;
goto cleanup;
}
/* make sure everything's initialized to something useful */
u = rsrc->url;
if ( !u->host )
{
LIBNET_DEBUG("no host specified");
msg_code = -NET_ERR_CONNECT_FAILED;
goto cleanup;
}
/* fill in proxyness */
if ( !rsrc->proxy )
{
rsrc->proxy = get_proxy("HTTP_PROXY");
}
if (( NULL == rsrc->outfile ) && (NULL == rsrc->buffer))
{
if ( u->file )
rsrc->outfile = strdup(u->file);
else
rsrc->outfile = strdup("index.html");
}
if ( !u->path )
u->path = strdup("/");
if ( !u->file )
u->file = strdup(""); /* funny looking */
if ( !u->port )
u->port = 80;
rsrc->options |= default_opts;
/* send the request to either the proxy or the remote host */
if ( rsrc->proxy )
{
proxy_url = url_new();
url_init(proxy_url, rsrc->proxy);
if ( !proxy_url->port )
proxy_url->port = 80;
if ( !proxy_url->host )
{
LIBNET_DEBUG( "bad proxy `%s'", rsrc->proxy);
msg_code = -NET_ERR_CONNECT_FAILED;
goto cleanup;
}
if ( proxy_url->username )
rsrc->proxy_username = strdup(proxy_url->username);
if ( proxy_url->password )
rsrc->proxy_password = strdup(proxy_url->password);
#ifdef LIB_W5300
sock = w5300_tcp_connect(proxy_url->host, proxy_url->port, rsrc->srcip, rsrc->srcport);
#else
sock = util_tcp_connect(proxy_url->host, proxy_url->port);
#endif
if (sock < 0)
{
msg_code = -NET_ERR_CONNECT_FAILED;
goto cleanup;
}
safe_free(u->path);
safe_free(u->file);
u->path = strdup("");
u->file = strdup(u->full_url);
request = get_request(rsrc);
LIBNET_DEBUG("sending request:\n%s", request);
S_WRITE(sock, request, STRLEN(request));
FREE(request);
}
else /* no proxy */
{
#ifdef LIB_W5300
sock = w5300_tcp_connect(u->host, u->port, rsrc->srcip, rsrc->srcport);
#else
sock = util_tcp_connect(u->host, u->port);
#endif
if (sock < 0)
{
msg_code = -NET_ERR_CONNECT_FAILED;
goto cleanup;
}
request = get_request(rsrc);
LIBNET_DEBUG("sending request:\n%s", request);
S_WRITE(sock, request, STRLEN(request));
FREE(request);
}
if (rsrc->outfile)
{
if ((get_file_size(rsrc->outfile) > 0) && (rsrc->options & OPT_RESUME))
out = fopen(rsrc->outfile, "rb+");
else
out = fopen(rsrc->outfile, "wb");
if ( !out )
{
LIBNET_DEBUG( "opening %s: %s", rsrc->outfile, "");
msg_code = -NET_ERR_FILE_SAVE_ERROR;
goto cleanup;
}
}
/* check to see if it returned a HTTP 1.x response */
MEMSET(buf, '\0', 5);
#ifdef LIB_W5300
bytes_read = S_READ(sock, buf, BUFSIZE);
buf[bytes_read] = '\0';
LIBNET_DEBUG("receive respond:(%d)\n%s", bytes_read, buf);
#else
bytes_read = S_READ(sock, buf, 8);
#endif
if ( bytes_read <= 0 )
{
msg_code = -NET_ERR_HTTP_SERVER_ERROR;
goto cleanup;
}
if ( ! (buf[0] == 'H' && buf[1] == 'T'
&& buf[2] == 'T' && buf[3] == 'P') )
{
if((rsrc->options & OPT_RESUME) && rsrc->outfile_offset)
{
LIBNET_DEBUG("server does not support resume!");
msg_code = -NET_ERR_OPERATION_NOT_PERMIT;
goto cleanup;
}
//fwrite(buf, bytes_read, 1,out);
}
else
{
/* skip the header */
#ifdef LIB_W5300
buf[bytes_read] = '\0';
#else
char *raw_header1 = NULL;
buf[bytes_read] = '\0';
raw_header1 = get_raw_header(sock);
strconcat2(buf, raw_header1, NULL);
FREE(raw_header1);
LIBNET_DEBUG("receive respond:(%d)\n%s", bytes_read, buf);
#endif
header = make_http_header(buf);
/* check for redirects */
tmp_string = get_header_value("location", header);
if (buf[9] == '3' && tmp_string )
{
#if 1 //diable redirec function
redir_u = url_new();
/* make sure we still send user/password along */
redir_u->username = safe_strdup(u->username);
redir_u->password = safe_strdup(u->password);
url_init(redir_u, tmp_string);
rsrc->url = redir_u;
redirect_count++;
//retval = transfer(rsrc, notify);
transfer((UINT32)rsrc, (UINT32)notify);
rsrc->url =u;
redirect_count--;
if(redirect_count<0) redirect_count=0;
if (redir_u)
{
url_destroy(redir_u);
FREE(redir_u);
}
#endif
FREE(tmp_string);
tmp_string = NULL;
//msg_code = -NET_ERR_OPERATION_NOT_PERMIT;//we can support redirect now, remove this line.
goto cleanup;
}
if (tmp_string)
{
FREE(tmp_string);
tmp_string = NULL;
}
if (buf[9] == '4' || buf[9] == '5')
{
for (i = 0; buf[i] && buf[i] != '\n'; i++);
buf[i] = '\0';
LIBNET_DEBUG("HTTP error from server: %s\n", buf);
if( buf[9] == '4' && buf[10] == '0' && buf[11] == '4')
msg_code = -NET_ERR_FILE_NOT_FOUND;
else
msg_code = -NET_ERR_HTTP_SERVER_ERROR;
goto cleanup;
}
tmp_string = get_header_value("content-length", header);
if (tmp_string)
{
rsrc->outfile_size = (off_t )ATOI(tmp_string);
FREE(tmp_string);
tmp_string = NULL;
if(rsrc->use_pecache ==0)
{
if ((rsrc->buffer) && (rsrc->buffer_len < rsrc->outfile_size))
{
LIBNET_DEBUG("the buffer length less than the file fize (%d < %d)\n", rsrc->buffer, (int)rsrc->outfile_size);
msg_code = -NET_ERR_FILE_SAVE_ERROR;
goto cleanup;
}
}
}
tmp_string = get_header_value("content-range", header);
if (tmp_string)
{
FREE(tmp_string);
tmp_string = NULL;
rsrc->outfile_size += rsrc->outfile_offset;
}
if ((!rsrc->outfile_size) &&
(rsrc->options & OPT_RESUME) &&
!(rsrc->options & OPT_NORESUME)
&& rsrc->outfile_offset )
{
LIBNET_DEBUG("unable to determine remote file size");
msg_code = -NET_ERR_FILE_SAVE_ERROR;
goto cleanup;
}
}
if(rsrc->use_pecache ==0)
retval = dump_data(rsrc, sock, out, notify);
else
retval = dump_data_to_pecache(rsrc, sock, out, notify);
cleanup:
free_http_header(header);
//if (raw_header)
// FREE(raw_header);
if (proxy_url)
{
url_destroy(proxy_url);
FREE(proxy_url);
}
if (sock >= 0)
{
S_CLOSE(sock);
}
if (out)
fclose(out);
if (buf)
{
FREE(buf);
}
#ifndef WIN32
if (rsrc->outfile)
fs_sync(rsrc->outfile);
#endif
if (msg_code < 0 && rsrc->running)
{
notify(NET_MSG_DOWNLOAD_FINISH, (UINT32)msg_code);
libnet_abort_url_read(TRUE);//to break url_open while loop //retval!=1 means transfer fail
}
return retval;
}
int
url_clone (url_t * url, url_t ** dest)
{
int i;
url_t *ur;
*dest = NULL;
if (url == NULL)
return -1;
if (url->host == NULL && url->string == NULL)
return -1;
i = url_init (&ur);
if (i == -1) /* allocation failed */
return -1;
if (url->scheme != NULL)
ur->scheme = sgetcopy (url->scheme);
if (url->username != NULL)
ur->username = sgetcopy (url->username);
if (url->password != NULL)
ur->password = sgetcopy (url->password);
if (url->host != NULL)
ur->host = sgetcopy (url->host);
if (url->port != NULL)
ur->port = sgetcopy (url->port);
if (url->string != NULL)
ur->string = sgetcopy (url->string);
{
int pos = 0;
url_param_t *u_param;
url_param_t *dest_param;
while (!list_eol (url->url_params, pos))
{
u_param = (url_param_t *) list_get (url->url_params, pos);
i = url_param_clone (u_param, &dest_param);
if (i != 0)
return -1;
list_add (ur->url_params, dest_param, -1);
pos++;
}
}
{
int pos = 0;
url_param_t *u_param;
url_param_t *dest_param;
while (!list_eol (url->url_headers, pos))
{
u_param = (url_param_t *) list_get (url->url_headers, pos);
i = url_param_clone (u_param, &dest_param);
if (i != 0)
return -1;
list_add (ur->url_headers, dest_param, -1);
pos++;
}
}
*dest = ur;
return 0;
}
