/**
* seahorse_progress_show:
* @operation: The operation to create a progress window for
* @title: Optional title of this window
* @delayed: TRUE: wait 1 second before displaying the window
*
* Displays a progress window and adds an operation to it.
*
*/
void
seahorse_progress_show (SeahorseOperation *operation, const gchar *title,
gboolean delayed)
{
/* Unref in the timeout callback */
g_object_ref (operation);
g_object_set_data_full (G_OBJECT (operation), "progress-title",
title ? g_strdup (title) : NULL, (GDestroyNotify)g_free);
/* Show the progress, after one second */
if (delayed)
g_timeout_add_seconds (1, (GSourceFunc)progress_show, operation);
/* Right away */
else
progress_show (operation);
}
int main(int argc, char *argv[] )
{
progress_t bar;
// progress_init(&bar, "", 50, PROGRESS_NUM_STYLE);
// progress_init(&bar, "", 50, PROGRESS_CHR_STYLE);
progress_init(&bar, "", 50, PROGRESS_BGC_STYLE);
int i;
for (i = 0; i <= 50; i++) {
progress_show(&bar, i / 50.0f);
sleep(1);
}
printf("\n+-Done\n");
progress_destroy(&bar);
return 0;
}
int generic_transfer(struct wgetfile *finfo, FILE *out, size_t len,
size_t sofar, int closefd)
{
#define RET(n) do{ ret = n; goto fin; }while(0)
int ret = 0;
long last_progress, last_speed_calc;
long chunk = 0; /* for bps */
long speed = 0;
last_progress = last_speed_calc = mstime();
if(!len)
progress_unknown(sofar, 0);
do{
ssize_t nread;
char buffer[BSIZ];
long t;
switch((nread = recv(finfo->sock, buffer, sizeof buffer, 0))){
case -1:
if(errno == EINTR)
continue;
/* TODO: retry */
if(len && sofar == len)
goto end_of_stream;
connection_close_fd(finfo->sock);
output_perror("recv()");
RET(1);
case 0:
end_of_stream:
connection_close_fd(finfo->sock);
if(len){
if(sofar == len){
RET(0);
}else{
/* TODO: goto retry */
progress_incomplete();
RET(1);
}
}else{
/* no length, assume we have the whole file */
RET(0);
}
/* unreachable */
default:
{
int trunc = 0;
if(len && sofar + nread > len){
output_err(OUT_WARN, "too much data, truncating by %zu bytes", sofar + nread - len);
trunc = 1;
nread = len - sofar;
sofar = len;
}else{
sofar += nread;
}
while(fwrite(buffer, sizeof(buffer[0]), nread, out) != (unsigned)nread){
if(errno == EINTR)
continue;
output_perror("fwrite()");
RET(1);
}
if(sofar == len)
RET(0); /* don't wait for more, maybe be pipelining */
chunk += nread;
if(trunc)
goto end_of_stream;
}
}
t = mstime();
if(last_progress + 250 < t){
if(last_speed_calc + 1000 < t){
long tdiff = t - last_speed_calc;
if(tdiff){
speed = 1000.0f /* kbps */ * (float)chunk / (float)tdiff;
chunk = 0;
last_speed_calc = t;
}
}
last_progress = t;
if(len)
progress_show(sofar, len, speed);
else
progress_unknown(sofar, speed);
}
}while(1);
fin:
if(len)
progress_fin(sofar, len);
else
progress_fin(0, 0);
if(closefd) {
ret |= wget_close(finfo, out);
if(ret)
wget_failure(finfo);
else
wget_success(finfo);
}
return ret;
}
char * /* O - Pathname or NULL */
file_find(const char *path, /* I - Path "dir;dir;dir" */
const char *s) /* I - File to find */
{
int i; /* Looping var */
int retry; /* Current retry */
char *temp, /* Current position in filename */
method[HTTP_MAX_URI], /* Method/scheme */
username[HTTP_MAX_URI], /* Username:password */
hostname[HTTP_MAX_URI], /* Hostname */
resource[HTTP_MAX_URI]; /* Resource */
int port; /* Port number */
const char *connhost; /* Host to connect to */
int connport; /* Port to connect to */
char connpath[HTTP_MAX_URI], /* Path for GET */
connauth[HTTP_MAX_VALUE];/* Auth string */
http_status_t status; /* Status of request... */
FILE *fp; /* Web file */
int bytes, /* Bytes read */
count, /* Number of bytes so far */
total; /* Total bytes in file */
static char filename[HTTP_MAX_URI]; /* Current filename */
/*
* If the filename is NULL, return NULL...
*/
if (s == NULL)
return (NULL);
if (strncmp(s, "http:", 5) == 0 ||
(path != NULL && strncmp(path, "http:", 5) == 0))
strcpy(method, "http");
#ifdef HAVE_LIBSSL
else if (strncmp(s, "https:", 6) == 0 ||
(path != NULL && strncmp(path, "https:", 6) == 0))
strcpy(method, "https");
#endif /* HAVE_LIBSSL */
else
strcpy(method, "file");
if (strcmp(method, "file") == 0)
{
/*
* If the path is NULL or empty, return the filename...
*/
if (path == NULL || !path[0])
return ((char *)s);
/*
* Else loop through the path string until we reach the end...
*/
while (*path != '\0')
{
/*
* Copy the path directory...
*/
temp = filename;
while (*path != ';' && *path && temp < (filename + sizeof(filename) - 1))
*temp++ = *path++;
if (*path == ';')
path ++;
/*
* Append a slash as needed...
*/
if (temp > filename && temp < (filename + sizeof(filename) - 1) &&
s[0] != '/')
*temp++ = '/';
/*
* Append the filename...
*/
strncpy(temp, s, sizeof(filename) - (temp - filename));
filename[sizeof(filename) - 1] = '\0';
/*
* See if the file exists...
*/
if (!access(filename, 0))
return (filename);
}
}
else
{
/*
* Remote file; look it up in the web cache, and then try getting it
* from the remote system...
*/
for (i = 0; i < web_files; i ++)
if (web_cache[i].url && strcmp(web_cache[i].url, s) == 0)
return (web_cache[i].name);
#ifdef HAVE_LIBSSL
if (strncmp(s, "http:", 5) == 0 || strncmp(s, "https:", 6) == 0)
#else
if (strncmp(s, "http:", 5) == 0)
#endif /* HAVE_LIBSSL */
httpSeparate(s, method, username, hostname, &port, resource);
else if (s[0] == '/')
{
httpSeparate(path, method, username, hostname, &port, resource);
strcpy(resource, s);
}
else
{
if (strncmp(s, "./", 2) == 0)
snprintf(filename, sizeof(filename), "%s/%s", path, s + 2);
else
snprintf(filename, sizeof(filename), "%s/%s", path, s);
httpSeparate(filename, method, username, hostname, &port, resource);
}
for (status = HTTP_ERROR, retry = 0;
status == HTTP_ERROR && retry < 5;
retry ++)
{
if (proxy_port)
{
/*
* Send request to proxy host...
*/
connhost = proxy_host;
connport = proxy_port;
snprintf(connpath, sizeof(connpath), "%s://%s:%d%s", method,
hostname, port, resource);
}
else
{
/*
* Send request to host directly...
*/
connhost = hostname;
connport = port;
strcpy(connpath, resource);
}
if (http != NULL && strcasecmp(http->hostname, hostname) != 0)
{
httpClose(http);
http = NULL;
}
if (http == NULL)
{
progress_show("Connecting to %s...", connhost);
atexit(file_cleanup);
#ifdef HAVE_LIBSSL
if (strcmp(method, "http") == 0)
http = httpConnect(connhost, connport);
else
http = httpConnectEncrypt(connhost, connport, HTTP_ENCRYPT_ALWAYS);
#else
http = httpConnect(connhost, connport);
#endif /* HAVE_LIBSSL */
if (http == NULL)
{
progress_hide();
progress_error("Unable to connect to %s!", connhost);
return (NULL);
}
}
progress_show("Getting %s...", connpath);
httpClearFields(http);
httpSetField(http, HTTP_FIELD_HOST, hostname);
httpSetField(http, HTTP_FIELD_USER_AGENT, "HTMLDOC v" SVERSION);
httpSetField(http, HTTP_FIELD_CONNECTION, "Keep-Alive");
if (username[0])
{
strcpy(connauth, "Basic ");
httpEncode64(connauth + 6, username);
httpSetField(http, HTTP_FIELD_AUTHORIZATION, connauth);
}
if (!httpGet(http, connpath))
while ((status = httpUpdate(http)) == HTTP_CONTINUE);
else
status = HTTP_ERROR;
if (status >= HTTP_MOVED_PERMANENTLY && status <= HTTP_SEE_OTHER)
{
/*
* Flush text...
*/
httpFlush(http);
/*
* Grab new location from HTTP data...
*/
httpSeparate(httpGetField(http, HTTP_FIELD_LOCATION), method, username,
hostname, &port, resource);
status = HTTP_ERROR;
}
}
if (status != HTTP_OK)
{
progress_hide();
progress_error("HTTP error %d: %s!", status, httpStatus(status));
httpFlush(http);
return (NULL);
}
if ((fp = file_temp(filename, sizeof(filename))) == NULL)
{
progress_hide();
progress_error("Unable to create temporary file \"%s\": %s", filename,
strerror(errno));
httpFlush(http);
return (NULL);
}
if ((total = atoi(httpGetField(http, HTTP_FIELD_CONTENT_LENGTH))) == 0)
total = 8192;
count = 0;
while ((bytes = httpRead(http, resource, sizeof(resource))) > 0)
{
count += bytes;
progress_update((100 * count / total) % 101);
fwrite(resource, 1, bytes, fp);
}
progress_hide();
fclose(fp);
web_cache[web_files - 1].name = strdup(filename);
web_cache[web_files - 1].url = strdup(s);
return (filename);
}
return (NULL);
}
