apr_status_t ap_init_ebcdic(apr_pool_t *pool)
{
apr_status_t rv;
char buf[80];
rv = apr_xlate_open(&ap_hdrs_to_ascii, "ISO8859-1", APR_DEFAULT_CHARSET, pool);
if (rv) {
ap_log_error(APLOG_MARK, APLOG_ERR, rv, NULL,
"apr_xlate_open() failed");
return rv;
}
rv = apr_xlate_open(&ap_hdrs_from_ascii, APR_DEFAULT_CHARSET, "ISO8859-1", pool);
if (rv) {
ap_log_error(APLOG_MARK, APLOG_ERR, rv, NULL,
"apr_xlate_open() failed");
return rv;
}
rv = apr_xlate_open(&ap_locale_to_ascii, "ISO8859-1", APR_LOCALE_CHARSET, pool);
if (rv) {
ap_log_error(APLOG_MARK, APLOG_ERR, rv, NULL,
"apr_xlate_open() failed");
return rv;
}
rv = apr_xlate_open(&ap_locale_from_ascii, APR_LOCALE_CHARSET, "ISO8859-1", pool);
if (rv) {
ap_log_error(APLOG_MARK, APLOG_ERR, rv, NULL,
"apr_xlate_open() failed");
return rv;
}
rv = apr_MD5InitEBCDIC(ap_hdrs_to_ascii);
if (rv) {
ap_log_error(APLOG_MARK, APLOG_ERR, rv, NULL,
"apr_MD5InitEBCDIC() failed");
return rv;
}
rv = apr_base64init_ebcdic(ap_hdrs_to_ascii, ap_hdrs_from_ascii);
if (rv) {
ap_log_error(APLOG_MARK, APLOG_ERR, rv, NULL,
"apr_base64init_ebcdic() failed");
return rv;
}
rv = apr_SHA1InitEBCDIC(ap_hdrs_to_ascii);
if (rv) {
ap_log_error(APLOG_MARK, APLOG_ERR, rv, NULL,
"apr_SHA1InitEBCDIC() failed");
return rv;
}
return APR_SUCCESS;
}
static apr_status_t htdbm_init(apr_pool_t **pool, htdbm_t **hdbm)
{
#if APR_CHARSET_EBCDIC
apr_status_t rv;
#endif
apr_pool_create( pool, NULL);
apr_pool_abort_set(abort_on_oom, *pool);
apr_file_open_stderr(&errfile, *pool);
apr_signal(SIGINT, (void (*)(int)) htdbm_interrupted);
(*hdbm) = (htdbm_t *)apr_pcalloc(*pool, sizeof(htdbm_t));
(*hdbm)->ctx.pool = *pool;
#if APR_CHARSET_EBCDIC
rv = apr_xlate_open(&((*hdbm)->to_ascii), "ISO-8859-1", APR_DEFAULT_CHARSET, (*hdbm)->ctx.pool);
if (rv) {
fprintf(stderr, "apr_xlate_open(to ASCII)->%d\n", rv);
return APR_EGENERAL;
}
rv = apr_SHA1InitEBCDIC((*hdbm)->to_ascii);
if (rv) {
fprintf(stderr, "apr_SHA1InitEBCDIC()->%d\n", rv);
return APR_EGENERAL;
}
rv = apr_MD5InitEBCDIC((*hdbm)->to_ascii);
if (rv) {
fprintf(stderr, "apr_MD5InitEBCDIC()->%d\n", rv);
return APR_EGENERAL;
}
#endif /*APR_CHARSET_EBCDIC*/
/* Set MD5 as default */
(*hdbm)->ctx.alg = ALG_APMD5;
(*hdbm)->type = "default";
return APR_SUCCESS;
}
/*
* Let's do it. We end up doing a lot of file opening and closing,
* but what do we care? This application isn't run constantly.
*/
int main(int argc, const char * const argv[])
{
apr_file_t *fpw = NULL;
char record[MAX_STRING_LEN];
char line[MAX_STRING_LEN];
char *password = NULL;
char *pwfilename = NULL;
char *user = NULL;
char tn[] = "htpasswd.tmp.XXXXXX";
char *dirname;
char *scratch, cp[MAX_STRING_LEN];
int found = 0;
int i;
int alg = ALG_APMD5;
int mask = 0;
apr_pool_t *pool;
int existing_file = 0;
#if APR_CHARSET_EBCDIC
apr_status_t rv;
apr_xlate_t *to_ascii;
#endif
apr_app_initialize(&argc, &argv, NULL);
atexit(terminate);
apr_pool_create(&pool, NULL);
apr_file_open_stderr(&errfile, pool);
#if APR_CHARSET_EBCDIC
rv = apr_xlate_open(&to_ascii, "ISO-8859-1", APR_DEFAULT_CHARSET, pool);
if (rv) {
apr_file_printf(errfile, "apr_xlate_open(to ASCII)->%d" NL, rv);
exit(1);
}
rv = apr_SHA1InitEBCDIC(to_ascii);
if (rv) {
apr_file_printf(errfile, "apr_SHA1InitEBCDIC()->%d" NL, rv);
exit(1);
}
rv = apr_MD5InitEBCDIC(to_ascii);
if (rv) {
apr_file_printf(errfile, "apr_MD5InitEBCDIC()->%d" NL, rv);
exit(1);
}
#endif /*APR_CHARSET_EBCDIC*/
check_args(pool, argc, argv, &alg, &mask, &user, &pwfilename, &password);
#if defined(WIN32) || defined(NETWARE)
if (alg == ALG_CRYPT) {
alg = ALG_APMD5;
apr_file_printf(errfile, "Automatically using MD5 format." NL);
}
#endif
#if (!(defined(WIN32) || defined(TPF) || defined(NETWARE)))
if (alg == ALG_PLAIN) {
apr_file_printf(errfile,"Warning: storing passwords as plain text "
"might just not work on this platform." NL);
}
#endif
/*
* Only do the file checks if we're supposed to frob it.
*/
if (!(mask & APHTP_NOFILE)) {
existing_file = exists(pwfilename, pool);
if (existing_file) {
/*
* Check that this existing file is readable and writable.
*/
if (!accessible(pool, pwfilename, APR_READ | APR_APPEND)) {
apr_file_printf(errfile, "%s: cannot open file %s for "
"read/write access" NL, argv[0], pwfilename);
exit(ERR_FILEPERM);
}
}
else {
/*
* Error out if -c was omitted for this non-existant file.
*/
if (!(mask & APHTP_NEWFILE)) {
apr_file_printf(errfile,
"%s: cannot modify file %s; use '-c' to create it" NL,
argv[0], pwfilename);
exit(ERR_FILEPERM);
}
/*
* As it doesn't exist yet, verify that we can create it.
*/
if (!accessible(pool, pwfilename, APR_CREATE | APR_WRITE)) {
apr_file_printf(errfile, "%s: cannot create file %s" NL,
argv[0], pwfilename);
exit(ERR_FILEPERM);
}
}
}
/*
* All the file access checks (if any) have been made. Time to go to work;
* try to create the record for the username in question. If that
* fails, there's no need to waste any time on file manipulations.
* Any error message text is returned in the record buffer, since
* the mkrecord() routine doesn't have access to argv[].
*/
if (!(mask & APHTP_DELUSER)) {
i = mkrecord(user, record, sizeof(record) - 1,
password, alg);
if (i != 0) {
apr_file_printf(errfile, "%s: %s" NL, argv[0], record);
exit(i);
}
if (mask & APHTP_NOFILE) {
printf("%s" NL, record);
exit(0);
}
}
/*
* We can access the files the right way, and we have a record
* to add or update. Let's do it..
*/
if (apr_temp_dir_get((const char**)&dirname, pool) != APR_SUCCESS) {
apr_file_printf(errfile, "%s: could not determine temp dir" NL,
argv[0]);
exit(ERR_FILEPERM);
}
dirname = apr_psprintf(pool, "%s/%s", dirname, tn);
if (apr_file_mktemp(&ftemp, dirname, 0, pool) != APR_SUCCESS) {
apr_file_printf(errfile, "%s: unable to create temporary file %s" NL,
argv[0], dirname);
exit(ERR_FILEPERM);
}
/*
* If we're not creating a new file, copy records from the existing
* one to the temporary file until we find the specified user.
*/
if (existing_file && !(mask & APHTP_NEWFILE)) {
if (apr_file_open(&fpw, pwfilename, APR_READ | APR_BUFFERED,
APR_OS_DEFAULT, pool) != APR_SUCCESS) {
apr_file_printf(errfile, "%s: unable to read file %s" NL,
argv[0], pwfilename);
exit(ERR_FILEPERM);
}
while (apr_file_gets(line, sizeof(line), fpw) == APR_SUCCESS) {
char *colon;
strcpy(cp, line);
scratch = cp;
while (apr_isspace(*scratch)) {
++scratch;
}
if (!*scratch || (*scratch == '#')) {
putline(ftemp, line);
continue;
}
/*
* See if this is our user.
*/
colon = strchr(scratch, ':');
if (colon != NULL) {
*colon = '\0';
}
else {
/*
* If we've not got a colon on the line, this could well
* not be a valid htpasswd file.
* We should bail at this point.
*/
apr_file_printf(errfile, "%s: The file %s does not appear "
"to be a valid htpasswd file." NL,
argv[0], pwfilename);
apr_file_close(fpw);
exit(ERR_INVALID);
}
if (strcmp(user, scratch) != 0) {
putline(ftemp, line);
continue;
}
else {
if (!(mask & APHTP_DELUSER)) {
/* We found the user we were looking for.
* Add him to the file.
*/
apr_file_printf(errfile, "Updating ");
putline(ftemp, record);
found++;
}
else {
/* We found the user we were looking for.
* Delete them from the file.
*/
apr_file_printf(errfile, "Deleting ");
found++;
}
}
}
apr_file_close(fpw);
}
if (!found && !(mask & APHTP_DELUSER)) {
apr_file_printf(errfile, "Adding ");
putline(ftemp, record);
}
else if (!found && (mask & APHTP_DELUSER)) {
apr_file_printf(errfile, "User %s not found" NL, user);
exit(0);
}
apr_file_printf(errfile, "password for user %s" NL, user);
/* The temporary file has all the data, just copy it to the new location.
*/
if (apr_file_copy(dirname, pwfilename, APR_FILE_SOURCE_PERMS, pool) !=
APR_SUCCESS) {
apr_file_printf(errfile, "%s: unable to update file %s" NL,
argv[0], pwfilename);
exit(ERR_FILEPERM);
}
apr_file_close(ftemp);
return 0;
}
