int /* O - -1 on error, 0 on success */
httpSaveCredentials(
const char *path, /* I - Keychain/PKCS#12 path */
cups_array_t *credentials, /* I - Credentials */
const char *common_name) /* I - Common name for credentials */
{
cups_file_t *fp; /* Certificate file */
char filename[1024], /* filename.crt */
nfilename[1024],/* filename.crt.N */
temp[1024], /* Temporary string */
line[256]; /* Base64-encoded line */
const unsigned char *ptr; /* Pointer into certificate */
ssize_t remaining; /* Bytes left */
http_credential_t *cred; /* Current credential */
if (!credentials || !common_name)
return (-1);
if (!path)
path = http_gnutls_default_path(temp, sizeof(temp));
if (!path)
return (-1);
http_gnutls_make_path(filename, sizeof(filename), path, common_name, "crt");
snprintf(nfilename, sizeof(nfilename), "%s.N", filename);
if ((fp = cupsFileOpen(nfilename, "w")) == NULL)
return (-1);
fchmod(cupsFileNumber(fp), 0600);
for (cred = (http_credential_t *)cupsArrayFirst(credentials);
cred;
cred = (http_credential_t *)cupsArrayNext(credentials))
{
cupsFilePuts(fp, "-----BEGIN CERTIFICATE-----\n");
for (ptr = cred->data, remaining = (ssize_t)cred->datalen; remaining > 0; remaining -= 45, ptr += 45)
{
httpEncode64_2(line, sizeof(line), (char *)ptr, remaining > 45 ? 45 : remaining);
cupsFilePrintf(fp, "%s\n", line);
}
cupsFilePuts(fp, "-----END CERTIFICATE-----\n");
}
cupsFileClose(fp);
return (rename(nfilename, filename));
}
extern void
ppdxWriteData(const char *name, /* I - Base name of keyword */
const void *data, /* I - Data to write */
size_t datasize) /* I - Number of bytes in data */
{
char buffer[PPDX_MAX_CHUNK], /* Chunk buffer */
encoded[PPDX_MAX_VALUE + 1],
/* Encoded data */
pair[PPD_MAX_LINE], /* name=value pair */
line[PPDX_MAX_STATUS], /* Line buffer */
*lineptr, /* Current position in line buffer */
*lineend; /* End of line buffer */
unsigned chunk = 0; /* Current chunk number */
int len; /* Length of current chunk */
z_stream comp; /* Compressor stream */
int error; /* Error/status from deflate() */
/*
* Range check input...
*/
if (!name || (!data && datasize > 0) || datasize > PPDX_MAX_DATA)
return;
strlcpy(line, "PPD:", sizeof(line));
lineptr = line + 4;
lineend = line + sizeof(line) - 2;
if (datasize > 0)
{
/*
* Compress and encode output...
*/
memset(&comp, 0, sizeof(comp));
comp.next_in = (Bytef *)data;
comp.avail_in = datasize;
deflateInit(&comp, 9);
do
{
/*
* Compress a chunk...
*/
comp.next_out = buffer;
comp.avail_out = sizeof(buffer);
if ((error = deflate(&comp, Z_FINISH)) < Z_OK)
{
fprintf(stderr, "ERROR: deflate returned %d (%s)\n", error, comp.msg);
break;
}
/*
* Write a chunk...
*/
len = sizeof(buffer) - comp.avail_out;
httpEncode64_2(encoded, sizeof(encoded), buffer, len);
len = (int)snprintf(pair, sizeof(pair), " %s%04x=%s", name, chunk,
encoded);
#ifdef DEBUG
fprintf(stderr, "DEBUG: *%s%04x: \"%s\"\n", name, chunk, encoded);
#endif /* DEBUG */
if ((lineptr + len) >= lineend)
{
*lineptr++ = '\n';
*lineptr = '\0';
fputs(line, stderr);
lineptr = line + 4;
}
strlcpy(lineptr, pair, lineend - lineptr);
lineptr += len;
/*
* Setup for the next one...
*/
chunk ++;
}
while (comp.avail_out == 0);
}
deflateEnd(&comp);
/*
* Write a trailing empty chunk to signal EOD...
*/
len = (int)snprintf(pair, sizeof(pair), " %s%04x=\"\"", name, chunk);
#ifdef DEBUG
fprintf(stderr, "DEBUG: *%s%04x: \"\"\n", name, chunk);
#endif /* DEBUG */
if ((lineptr + len) >= lineend)
{
*lineptr++ = '\n';
*lineptr = '\0';
fputs(line, stderr);
lineptr = line + 4;
}
strlcpy(lineptr, pair, lineend - lineptr);
lineptr += len;
*lineptr++ = '\n';
*lineptr = '\0';
fputs(line, stderr);
}
static void
cupsd_start_notifier(
cupsd_subscription_t *sub) /* I - Subscription object */
{
int pid; /* Notifier process ID */
int fds[2]; /* Pipe file descriptors */
char *argv[4], /* Command-line arguments */
*envp[MAX_ENV], /* Environment variables */
user_data[128], /* Base-64 encoded user data */
scheme[256], /* notify-recipient-uri scheme */
*ptr, /* Pointer into scheme */
command[1024]; /* Notifier command */
/*
* Extract the scheme name from the recipient URI and point to the
* notifier program...
*/
strlcpy(scheme, sub->recipient, sizeof(scheme));
if ((ptr = strchr(scheme, ':')) != NULL)
*ptr = '\0';
snprintf(command, sizeof(command), "%s/notifier/%s", ServerBin, scheme);
/*
* Base-64 encode the user data...
*/
httpEncode64_2(user_data, sizeof(user_data), (char *)sub->user_data,
sub->user_data_len);
/*
* Setup the argument array...
*/
argv[0] = command;
argv[1] = sub->recipient;
argv[2] = user_data;
argv[3] = NULL;
/*
* Setup the environment...
*/
cupsdLoadEnv(envp, (int)(sizeof(envp) / sizeof(envp[0])));
/*
* Create pipes as needed...
*/
if (!NotifierStatusBuffer)
{
/*
* Create the status pipe...
*/
if (cupsdOpenPipe(NotifierPipes))
{
cupsdLogMessage(CUPSD_LOG_ERROR,
"Unable to create pipes for notifier status - %s",
strerror(errno));
return;
}
NotifierStatusBuffer = cupsdStatBufNew(NotifierPipes[0], "[Notifier]");
cupsdAddSelect(NotifierPipes[0], (cupsd_selfunc_t)cupsd_update_notifier,
NULL, NULL);
}
if (cupsdOpenPipe(fds))
{
cupsdLogMessage(CUPSD_LOG_ERROR,
"Unable to create pipes for notifier %s - %s",
scheme, strerror(errno));
return;
}
/*
* Make sure the delivery pipe is non-blocking...
*/
fcntl(fds[1], F_SETFL, fcntl(fds[1], F_GETFL) | O_NONBLOCK);
/*
* Create the notifier process...
*/
if (cupsdStartProcess(command, argv, envp, fds[0], -1, NotifierPipes[1],
-1, -1, 0, DefaultProfile, NULL, &pid) < 0)
{
/*
* Error - can't fork!
*/
cupsdLogMessage(CUPSD_LOG_ERROR, "Unable to fork for notifier %s - %s",
scheme, strerror(errno));
cupsdClosePipe(fds);
}
else
{
/*
* Fork successful - return the PID...
*/
cupsdLogMessage(CUPSD_LOG_DEBUG, "Notifier %s started - PID = %d",
scheme, pid);
sub->pid = pid;
sub->pipe = fds[1];
sub->status = 0;
close(fds[0]);
}
}
static int /* O - 0 if available */
/* 1 if not available */
/* -1 error */
cups_local_auth(http_t *http) /* I - HTTP connection to server */
{
#if defined(WIN32) || defined(__EMX__)
/*
* Currently WIN32 and OS-2 do not support the CUPS server...
*/
return (1);
#else
int pid; /* Current process ID */
FILE *fp; /* Certificate file */
char trc[16], /* Try Root Certificate parameter */
filename[1024]; /* Certificate filename */
_cups_globals_t *cg = _cupsGlobals(); /* Global data */
# if defined(HAVE_AUTHORIZATION_H)
OSStatus status; /* Status */
AuthorizationItem auth_right; /* Authorization right */
AuthorizationRights auth_rights; /* Authorization rights */
AuthorizationFlags auth_flags; /* Authorization flags */
AuthorizationExternalForm auth_extrn; /* Authorization ref external */
char auth_key[1024]; /* Buffer */
char buffer[1024]; /* Buffer */
# endif /* HAVE_AUTHORIZATION_H */
DEBUG_printf(("7cups_local_auth(http=%p) hostaddr=%s, hostname=\"%s\"",
http, httpAddrString(http->hostaddr, filename, sizeof(filename)), http->hostname));
/*
* See if we are accessing localhost...
*/
if (!httpAddrLocalhost(http->hostaddr) &&
_cups_strcasecmp(http->hostname, "localhost") != 0)
{
DEBUG_puts("8cups_local_auth: Not a local connection!");
return (1);
}
# if defined(HAVE_AUTHORIZATION_H)
/*
* Delete any previous authorization reference...
*/
if (http->auth_ref)
{
AuthorizationFree(http->auth_ref, kAuthorizationFlagDefaults);
http->auth_ref = NULL;
}
if (!getenv("GATEWAY_INTERFACE") &&
httpGetSubField2(http, HTTP_FIELD_WWW_AUTHENTICATE, "authkey",
auth_key, sizeof(auth_key)))
{
status = AuthorizationCreate(NULL, kAuthorizationEmptyEnvironment,
kAuthorizationFlagDefaults, &http->auth_ref);
if (status != errAuthorizationSuccess)
{
DEBUG_printf(("8cups_local_auth: AuthorizationCreate() returned %d (%s)",
(int)status, cssmErrorString(status)));
return (-1);
}
auth_right.name = auth_key;
auth_right.valueLength = 0;
auth_right.value = NULL;
auth_right.flags = 0;
auth_rights.count = 1;
auth_rights.items = &auth_right;
auth_flags = kAuthorizationFlagDefaults |
kAuthorizationFlagPreAuthorize |
kAuthorizationFlagInteractionAllowed |
kAuthorizationFlagExtendRights;
status = AuthorizationCopyRights(http->auth_ref, &auth_rights,
kAuthorizationEmptyEnvironment,
auth_flags, NULL);
if (status == errAuthorizationSuccess)
status = AuthorizationMakeExternalForm(http->auth_ref, &auth_extrn);
if (status == errAuthorizationSuccess)
{
/*
* Set the authorization string and return...
*/
httpEncode64_2(buffer, sizeof(buffer), (void *)&auth_extrn,
sizeof(auth_extrn));
httpSetAuthString(http, "AuthRef", buffer);
DEBUG_printf(("8cups_local_auth: Returning authstring=\"%s\"",
http->authstring));
return (0);
}
else if (status == errAuthorizationCanceled)
return (-1);
DEBUG_printf(("9cups_local_auth: AuthorizationCopyRights() returned %d (%s)",
(int)status, cssmErrorString(status)));
/*
* Fall through to try certificates...
*/
}
# endif /* HAVE_AUTHORIZATION_H */
# if defined(SO_PEERCRED) && defined(AF_LOCAL)
/*
* See if we can authenticate using the peer credentials provided over a
* domain socket; if so, specify "PeerCred username" as the authentication
* information...
*/
if (
# ifdef HAVE_GSSAPI
_cups_strncasecmp(http->fields[HTTP_FIELD_WWW_AUTHENTICATE], "Negotiate", 9) &&
# endif /* HAVE_GSSAPI */
# ifdef HAVE_AUTHORIZATION_H
!httpGetSubField2(http, HTTP_FIELD_WWW_AUTHENTICATE, "authkey",
auth_key, sizeof(auth_key)) &&
# endif /* HAVE_AUTHORIZATION_H */
http->hostaddr->addr.sa_family == AF_LOCAL &&
!getenv("GATEWAY_INTERFACE")) /* Not via CGI programs... */
{
/*
* Verify that the current cupsUser() matches the current UID...
*/
struct passwd *pwd; /* Password information */
const char *username; /* Current username */
username = cupsUser();
if ((pwd = getpwnam(username)) != NULL && pwd->pw_uid == getuid())
{
httpSetAuthString(http, "PeerCred", username);
DEBUG_printf(("8cups_local_auth: Returning authstring=\"%s\"",
http->authstring));
return (0);
}
}
# endif /* SO_PEERCRED && AF_LOCAL */
/*
* Try opening a certificate file for this PID. If that fails,
* try the root certificate...
*/
pid = getpid();
snprintf(filename, sizeof(filename), "%s/certs/%d", cg->cups_statedir, pid);
if ((fp = fopen(filename, "r")) == NULL && pid > 0)
{
/*
* No certificate for this PID; see if we can get the root certificate...
*/
DEBUG_printf(("9cups_local_auth: Unable to open file %s: %s",
filename, strerror(errno)));
# ifdef HAVE_GSSAPI
if (!_cups_strncasecmp(http->fields[HTTP_FIELD_WWW_AUTHENTICATE], "Negotiate", 9))
{
/*
* Kerberos required, don't try the root certificate...
*/
return (1);
}
# endif /* HAVE_GSSAPI */
# ifdef HAVE_AUTHORIZATION_H
if (httpGetSubField2(http, HTTP_FIELD_WWW_AUTHENTICATE, "authkey",
auth_key, sizeof(auth_key)))
{
/*
* Don't use the root certificate as a replacement for an authkey...
*/
return (1);
}
# endif /* HAVE_AUTHORIZATION_H */
if (!httpGetSubField2(http, HTTP_FIELD_WWW_AUTHENTICATE, "trc", trc,
sizeof(trc)))
{
/*
* Scheduler doesn't want us to use the root certificate...
*/
return (1);
}
snprintf(filename, sizeof(filename), "%s/certs/0", cg->cups_statedir);
fp = fopen(filename, "r");
}
if (fp)
{
/*
* Read the certificate from the file...
*/
char certificate[33], /* Certificate string */
*certptr; /* Pointer to certificate string */
certptr = fgets(certificate, sizeof(certificate), fp);
fclose(fp);
if (certptr)
{
/*
* Set the authorization string and return...
*/
httpSetAuthString(http, "Local", certificate);
DEBUG_printf(("8cups_local_auth: Returning authstring=\"%s\"",
http->authstring));
return (0);
}
}
return (1);
#endif /* WIN32 || __EMX__ */
}
int /* O - 0 on success, -1 on error */
_cupsSetNegotiateAuthString(
http_t *http, /* I - Connection to server */
const char *method, /* I - Request method ("GET", "POST", "PUT") */
const char *resource) /* I - Resource path */
{
OM_uint32 minor_status, /* Minor status code */
major_status; /* Major status code */
gss_buffer_desc output_token = GSS_C_EMPTY_BUFFER;
/* Output token */
(void)method;
(void)resource;
# ifdef __APPLE__
/*
* If the weak-linked GSSAPI/Kerberos library is not present, don't try
* to use it...
*/
if (&gss_init_sec_context == NULL)
{
DEBUG_puts("1_cupsSetNegotiateAuthString: Weak-linked GSSAPI/Kerberos "
"framework is not present");
return (-1);
}
# endif /* __APPLE__ */
if (http->gssname == GSS_C_NO_NAME)
{
http->gssname = cups_gss_getname(http, _cupsGSSServiceName());
}
if (http->gssctx != GSS_C_NO_CONTEXT)
{
gss_delete_sec_context(&minor_status, &http->gssctx, GSS_C_NO_BUFFER);
http->gssctx = GSS_C_NO_CONTEXT;
}
major_status = gss_init_sec_context(&minor_status, GSS_C_NO_CREDENTIAL,
&http->gssctx,
http->gssname, http->gssmech,
GSS_C_MUTUAL_FLAG | GSS_C_INTEG_FLAG,
GSS_C_INDEFINITE,
GSS_C_NO_CHANNEL_BINDINGS,
GSS_C_NO_BUFFER, &http->gssmech,
&output_token, NULL, NULL);
#ifdef HAVE_GSS_ACQUIRE_CRED_EX_F
if (major_status == GSS_S_NO_CRED)
{
/*
* Ask the user for credentials...
*/
char prompt[1024], /* Prompt for user */
userbuf[256]; /* Kerberos username */
const char *username, /* Username string */
*password; /* Password string */
_cups_gss_acquire_t data; /* Callback data */
gss_auth_identity_desc identity; /* Kerberos user identity */
_cups_globals_t *cg = _cupsGlobals();
/* Per-thread global data */
if (!cg->lang_default)
cg->lang_default = cupsLangDefault();
snprintf(prompt, sizeof(prompt),
_cupsLangString(cg->lang_default, _("Password for %s on %s? ")),
cupsUser(), http->gsshost);
if ((password = cupsGetPassword2(prompt, http, method, resource)) == NULL)
return (-1);
/*
* Try to acquire credentials...
*/
username = cupsUser();
if (!strchr(username, '@'))
{
snprintf(userbuf, sizeof(userbuf), "%s@%s", username, http->gsshost);
username = userbuf;
}
identity.type = GSS_AUTH_IDENTITY_TYPE_1;
identity.flags = 0;
identity.username = (char *)username;
identity.realm = (char *)"";
identity.password = (char *)password;
identity.credentialsRef = NULL;
data.sem = dispatch_semaphore_create(0);
data.major = 0;
data.creds = NULL;
if (data.sem)
{
major_status = gss_acquire_cred_ex_f(NULL, GSS_C_NO_NAME, 0,
GSS_C_INDEFINITE, GSS_KRB5_MECHANISM,
GSS_C_INITIATE, &identity, &data,
cups_gss_acquire);
if (major_status == GSS_S_COMPLETE)
{
dispatch_semaphore_wait(data.sem, DISPATCH_TIME_FOREVER);
major_status = data.major;
}
dispatch_release(data.sem);
if (major_status == GSS_S_COMPLETE)
{
OM_uint32 release_minor; /* Minor status from releasing creds */
major_status = gss_init_sec_context(&minor_status, data.creds,
&http->gssctx,
http->gssname, http->gssmech,
GSS_C_MUTUAL_FLAG | GSS_C_INTEG_FLAG,
GSS_C_INDEFINITE,
GSS_C_NO_CHANNEL_BINDINGS,
GSS_C_NO_BUFFER, &http->gssmech,
&output_token, NULL, NULL);
gss_release_cred(&release_minor, &data.creds);
}
}
}
#endif /* HAVE_GSS_ACQUIRED_CRED_EX_F */
if (GSS_ERROR(major_status))
{
cups_gss_printf(major_status, minor_status,
"_cupsSetNegotiateAuthString: Unable to initialize "
"security context");
return (-1);
}
#ifdef DEBUG
else if (major_status == GSS_S_CONTINUE_NEEDED)
cups_gss_printf(major_status, minor_status,
"_cupsSetNegotiateAuthString: Continuation needed!");
#endif /* DEBUG */
if (output_token.length > 0 && output_token.length <= 65536)
{
/*
* Allocate the authorization string since Windows KDCs can have
* arbitrarily large credentials...
*/
int authsize = 10 + /* "Negotiate " */
(int)output_token.length * 4 / 3 + 1 + 1;
/* Base64 + nul */
httpSetAuthString(http, NULL, NULL);
if ((http->authstring = malloc((size_t)authsize)) == NULL)
{
http->authstring = http->_authstring;
authsize = sizeof(http->_authstring);
}
strlcpy(http->authstring, "Negotiate ", (size_t)authsize);
httpEncode64_2(http->authstring + 10, authsize - 10, output_token.value,
(int)output_token.length);
gss_release_buffer(&minor_status, &output_token);
}
else
{
DEBUG_printf(("1_cupsSetNegotiateAuthString: Kerberos credentials too "
"large - %d bytes!", (int)output_token.length));
gss_release_buffer(&minor_status, &output_token);
return (-1);
}
return (0);
}
int /* O - 0 on success, -1 on error */
cupsDoAuthentication(
http_t *http, /* I - Connection to server or @code CUPS_HTTP_DEFAULT@ */
const char *method, /* I - Request method ("GET", "POST", "PUT") */
const char *resource) /* I - Resource path */
{
const char *password, /* Password string */
*www_auth; /* WWW-Authenticate header */
char prompt[1024], /* Prompt for user */
realm[HTTP_MAX_VALUE], /* realm="xyz" string */
nonce[HTTP_MAX_VALUE]; /* nonce="xyz" string */
int localauth; /* Local authentication result */
_cups_globals_t *cg; /* Global data */
DEBUG_printf(("cupsDoAuthentication(http=%p, method=\"%s\", resource=\"%s\")",
http, method, resource));
if (!http)
http = _cupsConnect();
if (!http || !method || !resource)
return (-1);
DEBUG_printf(("2cupsDoAuthentication: digest_tries=%d, userpass=\"%s\"",
http->digest_tries, http->userpass));
DEBUG_printf(("2cupsDoAuthentication: WWW-Authenticate=\"%s\"",
httpGetField(http, HTTP_FIELD_WWW_AUTHENTICATE)));
/*
* Clear the current authentication string...
*/
httpSetAuthString(http, NULL, NULL);
/*
* See if we can do local authentication...
*/
if (http->digest_tries < 3)
{
if ((localauth = cups_local_auth(http)) == 0)
{
DEBUG_printf(("2cupsDoAuthentication: authstring=\"%s\"",
http->authstring));
if (http->status == HTTP_STATUS_UNAUTHORIZED)
http->digest_tries ++;
return (0);
}
else if (localauth == -1)
{
http->status = HTTP_STATUS_CUPS_AUTHORIZATION_CANCELED;
return (-1); /* Error or canceled */
}
}
/*
* Nope, see if we should retry the current username:password...
*/
www_auth = http->fields[HTTP_FIELD_WWW_AUTHENTICATE];
if ((http->digest_tries > 1 || !http->userpass[0]) &&
(!_cups_strncasecmp(www_auth, "Basic", 5) ||
!_cups_strncasecmp(www_auth, "Digest", 6)))
{
/*
* Nope - get a new password from the user...
*/
char default_username[HTTP_MAX_VALUE];
/* Default username */
cg = _cupsGlobals();
if (!cg->lang_default)
cg->lang_default = cupsLangDefault();
if (httpGetSubField(http, HTTP_FIELD_WWW_AUTHENTICATE, "username",
default_username))
cupsSetUser(default_username);
snprintf(prompt, sizeof(prompt),
_cupsLangString(cg->lang_default, _("Password for %s on %s? ")),
cupsUser(),
http->hostname[0] == '/' ? "localhost" : http->hostname);
http->digest_tries = _cups_strncasecmp(www_auth, "Digest", 6) != 0;
http->userpass[0] = '\0';
if ((password = cupsGetPassword2(prompt, http, method, resource)) == NULL)
{
http->status = HTTP_STATUS_CUPS_AUTHORIZATION_CANCELED;
return (-1);
}
snprintf(http->userpass, sizeof(http->userpass), "%s:%s", cupsUser(),
password);
}
else if (http->status == HTTP_STATUS_UNAUTHORIZED)
http->digest_tries ++;
if (http->status == HTTP_STATUS_UNAUTHORIZED && http->digest_tries >= 3)
{
DEBUG_printf(("1cupsDoAuthentication: Too many authentication tries (%d)",
http->digest_tries));
http->status = HTTP_STATUS_CUPS_AUTHORIZATION_CANCELED;
return (-1);
}
/*
* Got a password; encode it for the server...
*/
#ifdef HAVE_GSSAPI
if (!_cups_strncasecmp(www_auth, "Negotiate", 9))
{
/*
* Kerberos authentication...
*/
if (_cupsSetNegotiateAuthString(http, method, resource))
{
http->status = HTTP_STATUS_CUPS_AUTHORIZATION_CANCELED;
return (-1);
}
}
else
#endif /* HAVE_GSSAPI */
if (!_cups_strncasecmp(www_auth, "Basic", 5))
{
/*
* Basic authentication...
*/
char encode[256]; /* Base64 buffer */
httpEncode64_2(encode, sizeof(encode), http->userpass,
(int)strlen(http->userpass));
httpSetAuthString(http, "Basic", encode);
}
else if (!_cups_strncasecmp(www_auth, "Digest", 6))
{
/*
* Digest authentication...
*/
char encode[33], /* MD5 buffer */
digest[1024]; /* Digest auth data */
httpGetSubField(http, HTTP_FIELD_WWW_AUTHENTICATE, "realm", realm);
httpGetSubField(http, HTTP_FIELD_WWW_AUTHENTICATE, "nonce", nonce);
httpMD5(cupsUser(), realm, strchr(http->userpass, ':') + 1, encode);
httpMD5Final(nonce, method, resource, encode);
snprintf(digest, sizeof(digest),
"username=\"%s\", realm=\"%s\", nonce=\"%s\", uri=\"%s\", "
"response=\"%s\"", cupsUser(), realm, nonce, resource, encode);
httpSetAuthString(http, "Digest", digest);
}
else
{
DEBUG_printf(("1cupsDoAuthentication: Unknown auth type: \"%s\"",
www_auth));
http->status = HTTP_STATUS_CUPS_AUTHORIZATION_CANCELED;
return (-1);
}
DEBUG_printf(("1cupsDoAuthentication: authstring=\"%s\"", http->authstring));
return (0);
}
int /* O - Exit status */
main(int argc, /* I - Number of command-line arguments */
char *argv[]) /* I - Command-line arguments */
{
int i, j, k; /* Looping vars */
http_t *http; /* HTTP connection */
http_encryption_t encryption; /* Encryption type */
http_status_t status; /* Status of GET command */
int failures; /* Number of test failures */
char buffer[8192]; /* Input buffer */
long bytes; /* Number of bytes read */
FILE *out; /* Output file */
char encode[256], /* Base64-encoded string */
decode[256]; /* Base64-decoded string */
int decodelen; /* Length of decoded string */
char scheme[HTTP_MAX_URI], /* Scheme from URI */
hostname[HTTP_MAX_URI], /* Hostname from URI */
username[HTTP_MAX_URI], /* Username:password from URI */
resource[HTTP_MAX_URI]; /* Resource from URI */
int port; /* Port number from URI */
http_uri_status_t uri_status; /* Status of URI separation */
http_addrlist_t *addrlist, /* Address list */
*addr; /* Current address */
off_t length, total; /* Length and total bytes */
time_t start, current; /* Start and end time */
const char *encoding; /* Negotiated Content-Encoding */
static const char * const uri_status_strings[] =
{
"HTTP_URI_STATUS_OVERFLOW",
"HTTP_URI_STATUS_BAD_ARGUMENTS",
"HTTP_URI_STATUS_BAD_RESOURCE",
"HTTP_URI_STATUS_BAD_PORT",
"HTTP_URI_STATUS_BAD_HOSTNAME",
"HTTP_URI_STATUS_BAD_USERNAME",
"HTTP_URI_STATUS_BAD_SCHEME",
"HTTP_URI_STATUS_BAD_URI",
"HTTP_URI_STATUS_OK",
"HTTP_URI_STATUS_MISSING_SCHEME",
"HTTP_URI_STATUS_UNKNOWN_SCHEME",
"HTTP_URI_STATUS_MISSING_RESOURCE"
};
/*
* Do API tests if we don't have a URL on the command-line...
*/
if (argc == 1)
{
failures = 0;
/*
* httpGetDateString()/httpGetDateTime()
*/
fputs("httpGetDateString()/httpGetDateTime(): ", stdout);
start = time(NULL);
strlcpy(buffer, httpGetDateString(start), sizeof(buffer));
current = httpGetDateTime(buffer);
i = (int)(current - start);
if (i < 0)
i = -i;
if (!i)
puts("PASS");
else
{
failures ++;
puts("FAIL");
printf(" Difference is %d seconds, %02d:%02d:%02d...\n", i, i / 3600,
(i / 60) % 60, i % 60);
printf(" httpGetDateString(%d) returned \"%s\"\n", (int)start, buffer);
printf(" httpGetDateTime(\"%s\") returned %d\n", buffer, (int)current);
printf(" httpGetDateString(%d) returned \"%s\"\n", (int)current,
httpGetDateString(current));
}
/*
* httpDecode64_2()/httpEncode64_2()
*/
fputs("httpDecode64_2()/httpEncode64_2(): ", stdout);
for (i = 0, j = 0; i < (int)(sizeof(base64_tests) / sizeof(base64_tests[0])); i ++)
{
httpEncode64_2(encode, sizeof(encode), base64_tests[i][0],
(int)strlen(base64_tests[i][0]));
decodelen = (int)sizeof(decode);
httpDecode64_2(decode, &decodelen, base64_tests[i][1]);
if (strcmp(decode, base64_tests[i][0]))
{
failures ++;
if (j)
{
puts("FAIL");
j = 1;
}
printf(" httpDecode64_2() returned \"%s\", expected \"%s\"...\n",
decode, base64_tests[i][0]);
}
if (strcmp(encode, base64_tests[i][1]))
{
failures ++;
if (j)
{
puts("FAIL");
j = 1;
}
printf(" httpEncode64_2() returned \"%s\", expected \"%s\"...\n",
encode, base64_tests[i][1]);
}
}
if (!j)
puts("PASS");
/*
* httpGetHostname()
*/
fputs("httpGetHostname(): ", stdout);
if (httpGetHostname(NULL, hostname, sizeof(hostname)))
printf("PASS (%s)\n", hostname);
else
{
failures ++;
puts("FAIL");
}
/*
* httpAddrGetList()
*/
printf("httpAddrGetList(%s): ", hostname);
addrlist = httpAddrGetList(hostname, AF_UNSPEC, NULL);
if (addrlist)
{
for (i = 0, addr = addrlist; addr; i ++, addr = addr->next)
{
char numeric[1024]; /* Numeric IP address */
httpAddrString(&(addr->addr), numeric, sizeof(numeric));
if (!strcmp(numeric, "UNKNOWN"))
break;
}
if (addr)
printf("FAIL (bad address for %s)\n", hostname);
else
printf("PASS (%d address(es) for %s)\n", i, hostname);
httpAddrFreeList(addrlist);
}
else if (isdigit(hostname[0] & 255))
{
puts("FAIL (ignored because hostname is numeric)");
}
else
{
failures ++;
puts("FAIL");
}
/*
* Test httpSeparateURI()...
*/
fputs("httpSeparateURI(): ", stdout);
for (i = 0, j = 0; i < (int)(sizeof(uri_tests) / sizeof(uri_tests[0])); i ++)
{
uri_status = httpSeparateURI(HTTP_URI_CODING_MOST,
uri_tests[i].uri, scheme, sizeof(scheme),
username, sizeof(username),
hostname, sizeof(hostname), &port,
resource, sizeof(resource));
if (uri_status != uri_tests[i].result ||
strcmp(scheme, uri_tests[i].scheme) ||
strcmp(username, uri_tests[i].username) ||
strcmp(hostname, uri_tests[i].hostname) ||
port != uri_tests[i].port ||
strcmp(resource, uri_tests[i].resource))
{
failures ++;
if (!j)
{
puts("FAIL");
j = 1;
}
printf(" \"%s\":\n", uri_tests[i].uri);
if (uri_status != uri_tests[i].result)
printf(" Returned %s instead of %s\n",
uri_status_strings[uri_status + 8],
uri_status_strings[uri_tests[i].result + 8]);
if (strcmp(scheme, uri_tests[i].scheme))
printf(" Scheme \"%s\" instead of \"%s\"\n",
scheme, uri_tests[i].scheme);
if (strcmp(username, uri_tests[i].username))
printf(" Username \"%s\" instead of \"%s\"\n",
username, uri_tests[i].username);
if (strcmp(hostname, uri_tests[i].hostname))
printf(" Hostname \"%s\" instead of \"%s\"\n",
hostname, uri_tests[i].hostname);
if (port != uri_tests[i].port)
printf(" Port %d instead of %d\n",
port, uri_tests[i].port);
if (strcmp(resource, uri_tests[i].resource))
printf(" Resource \"%s\" instead of \"%s\"\n",
resource, uri_tests[i].resource);
}
}
if (!j)
printf("PASS (%d URIs tested)\n",
(int)(sizeof(uri_tests) / sizeof(uri_tests[0])));
/*
* Test httpAssembleURI()...
*/
fputs("httpAssembleURI(): ", stdout);
for (i = 0, j = 0, k = 0;
i < (int)(sizeof(uri_tests) / sizeof(uri_tests[0]));
i ++)
if (uri_tests[i].result == HTTP_URI_STATUS_OK &&
!strstr(uri_tests[i].uri, "%64") &&
strstr(uri_tests[i].uri, "//"))
{
k ++;
uri_status = httpAssembleURI(uri_tests[i].assemble_coding,
buffer, sizeof(buffer),
uri_tests[i].scheme,
uri_tests[i].username,
uri_tests[i].hostname,
uri_tests[i].assemble_port,
uri_tests[i].resource);
if (uri_status != HTTP_URI_STATUS_OK)
{
failures ++;
if (!j)
{
puts("FAIL");
j = 1;
}
printf(" \"%s\": %s\n", uri_tests[i].uri,
uri_status_strings[uri_status + 8]);
}
else if (strcmp(buffer, uri_tests[i].uri))
{
failures ++;
if (!j)
{
puts("FAIL");
j = 1;
}
printf(" \"%s\": assembled = \"%s\"\n", uri_tests[i].uri,
buffer);
}
}
if (!j)
printf("PASS (%d URIs tested)\n", k);
/*
* httpAssembleUUID
*/
fputs("httpAssembleUUID: ", stdout);
httpAssembleUUID("hostname.example.com", 631, "printer", 12345, buffer,
sizeof(buffer));
if (strncmp(buffer, "urn:uuid:", 9))
{
printf("FAIL (%s)\n", buffer);
failures ++;
}
else
printf("PASS (%s)\n", buffer);
/*
* Show a summary and return...
*/
if (failures)
printf("\n%d TESTS FAILED!\n", failures);
else
puts("\nALL TESTS PASSED!");
return (failures);
}
else if (strstr(argv[1], "._tcp"))
{
/*
* Test resolving an mDNS name.
*/
char resolved[1024]; /* Resolved URI */
printf("_httpResolveURI(%s, _HTTP_RESOLVE_DEFAULT): ", argv[1]);
fflush(stdout);
if (!_httpResolveURI(argv[1], resolved, sizeof(resolved),
_HTTP_RESOLVE_DEFAULT, NULL, NULL))
{
puts("FAIL");
return (1);
}
else
printf("PASS (%s)\n", resolved);
printf("_httpResolveURI(%s, _HTTP_RESOLVE_FQDN): ", argv[1]);
fflush(stdout);
if (!_httpResolveURI(argv[1], resolved, sizeof(resolved),
_HTTP_RESOLVE_FQDN, NULL, NULL))
{
puts("FAIL");
return (1);
}
else if (strstr(resolved, ".local:"))
{
printf("FAIL (%s)\n", resolved);
return (1);
}
else
{
printf("PASS (%s)\n", resolved);
return (0);
}
}
else if (!strcmp(argv[1], "-u") && argc == 3)
{
/*
* Test URI separation...
*/
uri_status = httpSeparateURI(HTTP_URI_CODING_ALL, argv[2], scheme,
sizeof(scheme), username, sizeof(username),
hostname, sizeof(hostname), &port,
resource, sizeof(resource));
printf("uri_status = %s\n", uri_status_strings[uri_status + 8]);
printf("scheme = \"%s\"\n", scheme);
printf("username = \"%s\"\n", username);
printf("hostname = \"%s\"\n", hostname);
printf("port = %d\n", port);
printf("resource = \"%s\"\n", resource);
return (0);
}
/*
* Test HTTP GET requests...
*/
http = NULL;
out = stdout;
for (i = 1; i < argc; i ++)
{
if (!strcmp(argv[i], "-o"))
{
i ++;
if (i >= argc)
break;
out = fopen(argv[i], "wb");
continue;
}
httpSeparateURI(HTTP_URI_CODING_MOST, argv[i], scheme, sizeof(scheme),
username, sizeof(username),
hostname, sizeof(hostname), &port,
resource, sizeof(resource));
if (!_cups_strcasecmp(scheme, "https") || !_cups_strcasecmp(scheme, "ipps") ||
port == 443)
encryption = HTTP_ENCRYPTION_ALWAYS;
else
encryption = HTTP_ENCRYPTION_IF_REQUESTED;
http = httpConnect2(hostname, port, NULL, AF_UNSPEC, encryption, 1, 30000,
NULL);
if (http == NULL)
{
perror(hostname);
continue;
}
printf("Checking file \"%s\"...\n", resource);
do
{
if (!_cups_strcasecmp(httpGetField(http, HTTP_FIELD_CONNECTION), "close"))
{
httpClearFields(http);
if (httpReconnect2(http, 30000, NULL))
{
status = HTTP_STATUS_ERROR;
break;
}
}
httpClearFields(http);
httpSetField(http, HTTP_FIELD_AUTHORIZATION, httpGetAuthString(http));
httpSetField(http, HTTP_FIELD_ACCEPT_LANGUAGE, "en");
if (httpHead(http, resource))
{
if (httpReconnect2(http, 30000, NULL))
{
status = HTTP_STATUS_ERROR;
break;
}
else
{
status = HTTP_STATUS_UNAUTHORIZED;
continue;
}
}
while ((status = httpUpdate(http)) == HTTP_STATUS_CONTINUE);
if (status == HTTP_STATUS_UNAUTHORIZED)
{
/*
* Flush any error message...
*/
httpFlush(http);
/*
* See if we can do authentication...
*/
if (cupsDoAuthentication(http, "GET", resource))
{
status = HTTP_STATUS_CUPS_AUTHORIZATION_CANCELED;
break;
}
if (httpReconnect2(http, 30000, NULL))
{
status = HTTP_STATUS_ERROR;
break;
}
continue;
}
#ifdef HAVE_SSL
else if (status == HTTP_STATUS_UPGRADE_REQUIRED)
{
/* Flush any error message... */
httpFlush(http);
/* Reconnect... */
if (httpReconnect2(http, 30000, NULL))
{
status = HTTP_STATUS_ERROR;
break;
}
/* Upgrade with encryption... */
httpEncryption(http, HTTP_ENCRYPTION_REQUIRED);
/* Try again, this time with encryption enabled... */
continue;
}
#endif /* HAVE_SSL */
}
while (status == HTTP_STATUS_UNAUTHORIZED ||
status == HTTP_STATUS_UPGRADE_REQUIRED);
if (status == HTTP_STATUS_OK)
puts("HEAD OK:");
else
printf("HEAD failed with status %d...\n", status);
encoding = httpGetContentEncoding(http);
printf("Requesting file \"%s\" (Accept-Encoding: %s)...\n", resource,
encoding ? encoding : "identity");
do
{
if (!_cups_strcasecmp(httpGetField(http, HTTP_FIELD_CONNECTION), "close"))
{
httpClearFields(http);
if (httpReconnect2(http, 30000, NULL))
{
status = HTTP_STATUS_ERROR;
break;
}
}
httpClearFields(http);
httpSetField(http, HTTP_FIELD_AUTHORIZATION, httpGetAuthString(http));
httpSetField(http, HTTP_FIELD_ACCEPT_LANGUAGE, "en");
httpSetField(http, HTTP_FIELD_ACCEPT_ENCODING, encoding);
if (httpGet(http, resource))
{
if (httpReconnect2(http, 30000, NULL))
{
status = HTTP_STATUS_ERROR;
break;
}
else
{
status = HTTP_STATUS_UNAUTHORIZED;
continue;
}
}
while ((status = httpUpdate(http)) == HTTP_STATUS_CONTINUE);
if (status == HTTP_STATUS_UNAUTHORIZED)
{
/*
* Flush any error message...
*/
httpFlush(http);
/*
* See if we can do authentication...
*/
if (cupsDoAuthentication(http, "GET", resource))
{
status = HTTP_STATUS_CUPS_AUTHORIZATION_CANCELED;
break;
}
if (httpReconnect2(http, 30000, NULL))
{
status = HTTP_STATUS_ERROR;
break;
}
continue;
}
#ifdef HAVE_SSL
else if (status == HTTP_STATUS_UPGRADE_REQUIRED)
{
/* Flush any error message... */
httpFlush(http);
/* Reconnect... */
if (httpReconnect2(http, 30000, NULL))
{
status = HTTP_STATUS_ERROR;
break;
}
/* Upgrade with encryption... */
httpEncryption(http, HTTP_ENCRYPTION_REQUIRED);
/* Try again, this time with encryption enabled... */
continue;
}
#endif /* HAVE_SSL */
}
while (status == HTTP_STATUS_UNAUTHORIZED || status == HTTP_STATUS_UPGRADE_REQUIRED);
if (status == HTTP_STATUS_OK)
puts("GET OK:");
else
printf("GET failed with status %d...\n", status);
start = time(NULL);
length = httpGetLength2(http);
total = 0;
while ((bytes = httpRead2(http, buffer, sizeof(buffer))) > 0)
{
total += bytes;
fwrite(buffer, bytes, 1, out);
if (out != stdout)
{
current = time(NULL);
if (current == start) current ++;
printf("\r" CUPS_LLFMT "/" CUPS_LLFMT " bytes ("
CUPS_LLFMT " bytes/sec) ", CUPS_LLCAST total,
CUPS_LLCAST length, CUPS_LLCAST (total / (current - start)));
fflush(stdout);
}
}
}
puts("Closing connection to server...");
httpClose(http);
if (out != stdout)
fclose(out);
return (0);
}
int /* O - Exit status */
main(int argc, /* I - Number of command-line arguments */
char *argv[]) /* I - Command-line arguments */
{
int i, j, k; /* Looping vars */
http_t *http; /* HTTP connection */
http_status_t status; /* Status of GET command */
int failures; /* Number of test failures */
char buffer[8192]; /* Input buffer */
long bytes; /* Number of bytes read */
FILE *out; /* Output file */
char encode[256], /* Base64-encoded string */
decode[256]; /* Base64-decoded string */
int decodelen; /* Length of decoded string */
char scheme[HTTP_MAX_URI], /* Scheme from URI */
hostname[HTTP_MAX_URI], /* Hostname from URI */
username[HTTP_MAX_URI], /* Username:password from URI */
resource[HTTP_MAX_URI]; /* Resource from URI */
int port; /* Port number from URI */
http_uri_status_t uri_status; /* Status of URI separation */
http_addrlist_t *addrlist, /* Address list */
*addr; /* Current address */
off_t length, total; /* Length and total bytes */
time_t start, current; /* Start and end time */
static const char * const uri_status_strings[] =
{
"HTTP_URI_OVERFLOW",
"HTTP_URI_BAD_ARGUMENTS",
"HTTP_URI_BAD_RESOURCE",
"HTTP_URI_BAD_PORT",
"HTTP_URI_BAD_HOSTNAME",
"HTTP_URI_BAD_USERNAME",
"HTTP_URI_BAD_SCHEME",
"HTTP_URI_BAD_URI",
"HTTP_URI_OK",
"HTTP_URI_MISSING_SCHEME",
"HTTP_URI_UNKNOWN_SCHEME",
"HTTP_URI_MISSING_RESOURCE"
};
/*
* Do API tests if we don't have a URL on the command-line...
*/
if (argc == 1)
{
failures = 0;
/*
* httpGetDateString()/httpGetDateTime()
*/
fputs("httpGetDateString()/httpGetDateTime(): ", stdout);
start = time(NULL);
strcpy(buffer, httpGetDateString(start));
current = httpGetDateTime(buffer);
i = (int)(current - start);
if (i < 0)
i = -i;
if (!i)
puts("PASS");
else
{
failures ++;
puts("FAIL");
printf(" Difference is %d seconds, %02d:%02d:%02d...\n", i, i / 3600,
(i / 60) % 60, i % 60);
printf(" httpGetDateString(%d) returned \"%s\"\n", (int)start, buffer);
printf(" httpGetDateTime(\"%s\") returned %d\n", buffer, (int)current);
printf(" httpGetDateString(%d) returned \"%s\"\n", (int)current,
httpGetDateString(current));
}
/*
* httpDecode64_2()/httpEncode64_2()
*/
fputs("httpDecode64_2()/httpEncode64_2(): ", stdout);
for (i = 0, j = 0; i < (int)(sizeof(base64_tests) / sizeof(base64_tests[0])); i ++)
{
httpEncode64_2(encode, sizeof(encode), base64_tests[i][0],
strlen(base64_tests[i][0]));
decodelen = (int)sizeof(decode);
httpDecode64_2(decode, &decodelen, base64_tests[i][1]);
if (strcmp(decode, base64_tests[i][0]))
{
failures ++;
if (j)
{
puts("FAIL");
j = 1;
}
printf(" httpDecode64_2() returned \"%s\", expected \"%s\"...\n",
decode, base64_tests[i][0]);
}
if (strcmp(encode, base64_tests[i][1]))
{
failures ++;
if (j)
{
puts("FAIL");
j = 1;
}
printf(" httpEncode64_2() returned \"%s\", expected \"%s\"...\n",
encode, base64_tests[i][1]);
}
}
if (!j)
puts("PASS");
/*
* httpGetHostname()
*/
fputs("httpGetHostname(): ", stdout);
if (httpGetHostname(NULL, hostname, sizeof(hostname)))
printf("PASS (%s)\n", hostname);
else
{
failures ++;
puts("FAIL");
}
/*
* httpAddrGetList()
*/
printf("httpAddrGetList(%s): ", hostname);
addrlist = httpAddrGetList(hostname, AF_UNSPEC, NULL);
if (addrlist)
{
for (i = 0, addr = addrlist; addr; i ++, addr = addr->next)
{
char numeric[1024]; /* Numeric IP address */
httpAddrString(&(addr->addr), numeric, sizeof(numeric));
if (!strcmp(numeric, "UNKNOWN"))
break;
}
if (addr)
printf("FAIL (bad address for %s)\n", hostname);
else
printf("PASS (%d address(es) for %s)\n", i, hostname);
httpAddrFreeList(addrlist);
}
else
{
failures ++;
puts("FAIL");
}
/*
* Test httpSeparateURI()...
*/
fputs("httpSeparateURI(): ", stdout);
for (i = 0, j = 0; i < (int)(sizeof(uri_tests) / sizeof(uri_tests[0])); i ++)
{
uri_status = httpSeparateURI(HTTP_URI_CODING_MOST,
uri_tests[i].uri, scheme, sizeof(scheme),
username, sizeof(username),
hostname, sizeof(hostname), &port,
resource, sizeof(resource));
if (uri_status != uri_tests[i].result ||
strcmp(scheme, uri_tests[i].scheme) ||
strcmp(username, uri_tests[i].username) ||
strcmp(hostname, uri_tests[i].hostname) ||
port != uri_tests[i].port ||
strcmp(resource, uri_tests[i].resource))
{
failures ++;
if (!j)
{
puts("FAIL");
j = 1;
}
printf(" \"%s\":\n", uri_tests[i].uri);
if (uri_status != uri_tests[i].result)
printf(" Returned %s instead of %s\n",
uri_status_strings[uri_status + 8],
uri_status_strings[uri_tests[i].result + 8]);
if (strcmp(scheme, uri_tests[i].scheme))
printf(" Scheme \"%s\" instead of \"%s\"\n",
scheme, uri_tests[i].scheme);
if (strcmp(username, uri_tests[i].username))
printf(" Username \"%s\" instead of \"%s\"\n",
username, uri_tests[i].username);
if (strcmp(hostname, uri_tests[i].hostname))
printf(" Hostname \"%s\" instead of \"%s\"\n",
hostname, uri_tests[i].hostname);
if (port != uri_tests[i].port)
printf(" Port %d instead of %d\n",
port, uri_tests[i].port);
if (strcmp(resource, uri_tests[i].resource))
printf(" Resource \"%s\" instead of \"%s\"\n",
resource, uri_tests[i].resource);
}
}
if (!j)
printf("PASS (%d URIs tested)\n",
(int)(sizeof(uri_tests) / sizeof(uri_tests[0])));
/*
* Test httpAssembleURI()...
*/
fputs("httpAssembleURI(): ", stdout);
for (i = 0, j = 0, k = 0;
i < (int)(sizeof(uri_tests) / sizeof(uri_tests[0]));
i ++)
if (uri_tests[i].result == HTTP_URI_OK &&
!strstr(uri_tests[i].uri, "%64") &&
strstr(uri_tests[i].uri, "//"))
{
k ++;
uri_status = httpAssembleURI(HTTP_URI_CODING_MOST,
buffer, sizeof(buffer),
uri_tests[i].scheme,
uri_tests[i].username,
uri_tests[i].hostname,
uri_tests[i].assemble_port,
uri_tests[i].resource);
if (uri_status != HTTP_URI_OK)
{
failures ++;
if (!j)
{
puts("FAIL");
j = 1;
}
printf(" \"%s\": %s\n", uri_tests[i].uri,
uri_status_strings[uri_status + 8]);
}
else if (strcmp(buffer, uri_tests[i].uri))
{
failures ++;
if (!j)
{
puts("FAIL");
j = 1;
}
printf(" \"%s\": assembled = \"%s\"\n", uri_tests[i].uri,
buffer);
}
}
if (!j)
printf("PASS (%d URIs tested)\n", k);
/*
* Show a summary and return...
*/
if (failures)
printf("\n%d TESTS FAILED!\n", failures);
else
puts("\nALL TESTS PASSED!");
return (failures);
}
/*
* Test HTTP GET requests...
*/
http = NULL;
out = stdout;
for (i = 1; i < argc; i ++)
{
if (!strcmp(argv[i], "-o"))
{
i ++;
if (i >= argc)
break;
out = fopen(argv[i], "wb");
continue;
}
httpSeparateURI(HTTP_URI_CODING_MOST, argv[i], scheme, sizeof(scheme),
username, sizeof(username),
hostname, sizeof(hostname), &port,
resource, sizeof(resource));
http = httpConnectEncrypt(hostname, port, HTTP_ENCRYPT_IF_REQUESTED);
if (http == NULL)
{
perror(hostname);
continue;
}
printf("Requesting file \"%s\"...\n", resource);
httpClearFields(http);
httpSetField(http, HTTP_FIELD_ACCEPT_LANGUAGE, "en");
httpGet(http, resource);
while ((status = httpUpdate(http)) == HTTP_CONTINUE);
if (status == HTTP_OK)
puts("GET OK:");
else
printf("GET failed with status %d...\n", status);
start = time(NULL);
length = httpGetLength2(http);
total = 0;
while ((bytes = httpRead2(http, buffer, sizeof(buffer))) > 0)
{
total += bytes;
fwrite(buffer, bytes, 1, out);
if (out != stdout)
{
current = time(NULL);
if (current == start) current ++;
printf("\r" CUPS_LLFMT "/" CUPS_LLFMT " bytes ("
CUPS_LLFMT " bytes/sec) ", CUPS_LLCAST total,
CUPS_LLCAST length, CUPS_LLCAST (total / (current - start)));
fflush(stdout);
}
}
}
puts("Closing connection to server...");
httpClose(http);
if (out != stdout)
fclose(out);
return (0);
}
