/*!
\brief Set environment name to value (doesn't update .gisrc)
\param name variable name
\param value variable value
*/
void G_setenv_nogisrc(const char *name, const char *value)
{
read_env(G_VAR_GISRC);
set_env(name, value, G_VAR_GISRC);
}
/*!
\brief Set environment variable (updates .gisrc)
If value is NULL, becomes an G_unsetenv().
\param name variable name
\param value variable value
*/
void G_setenv(const char *name, const char *value)
{
read_env(G_VAR_GISRC);
set_env(name, value, G_VAR_GISRC);
write_env(G_VAR_GISRC);
}
/*!
\brief Set environment variable from specific place (updates .gisrc)
If value is NULL, becomes an G_unsetenv().
\param name variable name
\param value variable value
\param loc location (G_VAR_GISRC, G_VAR_MAPSET)
*/
void G_setenv2(const char *name, const char *value, int loc)
{
read_env(loc);
set_env(name, value, loc);
write_env(loc);
}
void env_relocate_spec(void)
{
#if !defined(ENV_IS_EMBEDDED)
struct mmc *mmc;
u32 offset1, offset2;
int read1_fail = 0, read2_fail = 0;
int crc1_ok = 0, crc2_ok = 0;
env_t *ep;
int ret;
int dev = CONFIG_SYS_MMC_ENV_DEV;
const char *errmsg = NULL;
ALLOC_CACHE_ALIGN_BUFFER(env_t, tmp_env1, 1);
ALLOC_CACHE_ALIGN_BUFFER(env_t, tmp_env2, 1);
#ifdef CONFIG_SPL_BUILD
dev = 0;
#endif
mmc = find_mmc_device(dev);
errmsg = init_mmc_for_env(mmc);
if (errmsg) {
ret = 1;
goto err;
}
if (mmc_get_env_addr(mmc, 0, &offset1) ||
mmc_get_env_addr(mmc, 1, &offset2)) {
ret = 1;
goto fini;
}
read1_fail = read_env(mmc, CONFIG_ENV_SIZE, offset1, tmp_env1);
read2_fail = read_env(mmc, CONFIG_ENV_SIZE, offset2, tmp_env2);
if (read1_fail && read2_fail)
puts("*** Error - No Valid Environment Area found\n");
else if (read1_fail || read2_fail)
puts("*** Warning - some problems detected "
"reading environment; recovered successfully\n");
crc1_ok = !read1_fail &&
(crc32(0, tmp_env1->data, ENV_SIZE) == tmp_env1->crc);
crc2_ok = !read2_fail &&
(crc32(0, tmp_env2->data, ENV_SIZE) == tmp_env2->crc);
if (!crc1_ok && !crc2_ok) {
errmsg = "!bad CRC";
ret = 1;
goto fini;
} else if (crc1_ok && !crc2_ok) {
gd->env_valid = 1;
} else if (!crc1_ok && crc2_ok) {
gd->env_valid = 2;
} else {
/* both ok - check serial */
if (tmp_env1->flags == 255 && tmp_env2->flags == 0)
gd->env_valid = 2;
else if (tmp_env2->flags == 255 && tmp_env1->flags == 0)
gd->env_valid = 1;
else if (tmp_env1->flags > tmp_env2->flags)
gd->env_valid = 1;
else if (tmp_env2->flags > tmp_env1->flags)
gd->env_valid = 2;
else /* flags are equal - almost impossible */
gd->env_valid = 1;
}
free(env_ptr);
if (gd->env_valid == 1)
ep = tmp_env1;
else
ep = tmp_env2;
env_flags = ep->flags;
env_import((char *)ep, 0);
ret = 0;
fini:
fini_mmc_for_env(mmc);
err:
if (ret)
set_default_env(errmsg);
#endif
}
/*
* Initialize torsocks configuration from a given conf file or the default one.
*/
static void init_config(void)
{
int ret;
const char *filename = NULL;
if (!is_suid) {
filename = getenv("TORSOCKS_CONF_FILE");
}
ret = config_file_read(filename, &tsocks_config);
if (ret < 0) {
/*
* Failing to get the configuration means torsocks can not function
* properly so stops everything.
*/
clean_exit(EXIT_FAILURE);
}
/*
* Setup configuration from config file. Use defaults if some attributes
* are missing.
*/
if (!tsocks_config.conf_file.tor_address) {
tsocks_config.conf_file.tor_address = strdup(DEFAULT_TOR_ADDRESS);
if (!tsocks_config.conf_file.tor_address) {
/* Most likely ENOMEM thus we can't continue. */
clean_exit(EXIT_FAILURE);
}
}
if (tsocks_config.conf_file.tor_port == 0) {
tsocks_config.conf_file.tor_port = DEFAULT_TOR_PORT;
}
if (tsocks_config.conf_file.tor_domain == 0) {
tsocks_config.conf_file.tor_domain = DEFAULT_TOR_DOMAIN;
}
if (tsocks_config.conf_file.onion_base == 0) {
tsocks_config.conf_file.onion_base = inet_addr(DEFAULT_ONION_ADDR_RANGE);
tsocks_config.conf_file.onion_mask = atoi(DEFAULT_ONION_ADDR_MASK);
}
/* Create the Tor SOCKS5 connection address. */
ret = connection_addr_set(tsocks_config.conf_file.tor_domain,
tsocks_config.conf_file.tor_address,
tsocks_config.conf_file.tor_port, &tsocks_config.socks5_addr);
if (ret < 0) {
/*
* Without a valid connection address object to Tor well torsocks can't
* work properly at all so abort everything.
*/
clean_exit(EXIT_FAILURE);
}
/* Handle possible env. variables. */
read_env();
/* Finalize the SOCKS auth (Isolation) settings. */
ret = conf_apply_socks_auth(&tsocks_config);
if (ret < 0) {
clean_exit(EXIT_FAILURE);
}
}
void
CGI_prefork_server(const char *host, int port, const char *pidfile,
int maxproc, int minidle, int maxidle, int maxreq,
void (*callback)(void))
{
int i, sock, fd;
struct score_state message;
struct score_board *scb;
pid_t pid;
FILE *fp;
int pfd[2];
char **realenv, **tmpenv;
char *tmpbuf;
extern char **environ;
/* sanity check arguments */
if (callback == 0) {
syslog(LOG_ERR, "CGI_prefork_server(): null callback "
"function pointer");
return;
}
if (minidle <= 0) {
minidle = 2;
}
if (maxidle <= minidle) {
maxidle = minidle + 2;
}
if (maxproc <= 0) {
maxproc = maxidle;
}
if (maxproc > SCORE_MAX_PROC) {
maxproc = SCORE_MAX_PROC;
}
syslog(LOG_INFO, "CGI_prefork_server(): maxproc = %d, minidle = %d, "
"maxidle = %d, maxreq = %d", maxproc, minidle, maxidle, maxreq);
/* parent puts self into the background */
if (fork() != 0) {
_exit(0);
}
setsid();
set_handler(SIGTERM, terminate);
set_handler(SIGCHLD, child_handler);
freopen("/dev/null", "r", stdin);
freopen("/dev/null", "w", stdout);
/* write our pid to pidfile */
if (pidfile != 0 && *pidfile != 0 &&
(fp = fopen(pidfile, "w")) != 0)
{
fprintf(fp, "%d\n", getpid());
fclose(fp);
}
/* create child process scoreboard */
scb = score_new(maxproc, minidle, maxidle);
/* parent opens the listen socket, children accept() connections */
if ((sock = setup_sock(host, port)) < 0) {
syslog(LOG_ERR, "CGI_prefork_server(): setup_sock() failed: %m");
return;
}
/* open pipe to receive messages from child processes */
pipe(pfd);
/* parent manages child processes */
for (;;) {
/* fork child if necessary */
if (scb->numidle < scb->minidle && scb->numproc < scb->maxproc) {
if ((pid = fork()) == 0) {
break;
}
else if (pid > 0) {
score_add(scb, pid);
continue;
}
else {
syslog(LOG_ERR, "CGI_prefork_server(): fork() failed: %m");
if (scb->numproc == 0) {
return;
}
}
}
/*
* read status message from child. The read() call returns with
* an error if we catch SIGCHLD or SIGTERM.
*/
if (child_exited == 0 && terminate_flag == 0 &&
read(pfd[0], &message, sizeof(message)) == sizeof(message))
{
score_update(scb, &message);
}
/* kill everything and exit if we got SIGTERM */
if (terminate_flag != 0) {
set_handler(SIGTERM, SIG_IGN);
kill(0, SIGTERM); /* kill process group */
while(wait(0) >= 0)
;
exit(0);
}
/* kill idle child if necessary */
if (scb->numidle > scb->maxidle) {
score_kill(scb);
}
/* wait for exited children */
child_exited = 0;
while ((pid = waitpid(-1, 0, WNOHANG)) > 0) {
score_remove(scb, pid);
}
}
/* child handles maxreq requests and exits */
set_handler(SIGTERM, SIG_DFL);
set_handler(SIGCHLD, SIG_DFL);
close(pfd[0]);
message.pid = getpid();
realenv = environ;
for (i = 0; i < maxreq || maxreq <= 0; i++) {
/* accept connection from SCGI client (httpd) */
if ((fd = accept(sock, 0, 0)) < 0) {
syslog(LOG_ERR, "CGI_prefork_server(): accept() failed: %m");
break;
}
/* notify parent we are busy */
message.state = SCORE_BUSY;
write(pfd[1], &message, sizeof(message));
/* redirect stdin and stdout to socket */
dup2(fd, 0);
dup2(fd, 1);
close(fd);
/* read environment and call callback */
if ((tmpenv = read_env()) != 0) {
tmpbuf = tmpenv[0];
environ = tmpenv;
callback();
}
else {
fputs("Content-type: text/plain\r\n\r\n"
"CGI_prefork_server() could not read environment.\r\n",
stdout);
syslog(LOG_ERR, "CGI_prefork_server(): could not read "
"environment");
}
/* close socket and restore environment */
freopen("/dev/null", "r", stdin); /* closes socket */
freopen("/dev/null", "w", stdout);
environ = realenv;
if (tmpenv != 0) {
free(tmpbuf);
free(tmpenv);
}
/* notify parent we are idle */
message.state = SCORE_IDLE;
write(pfd[1], &message, sizeof(message));
}
_exit(0);
}
static int env_mmc_load(void)
{
#if !defined(ENV_IS_EMBEDDED)
struct mmc *mmc;
u32 offset1, offset2;
int read1_fail = 0, read2_fail = 0;
int ret;
int dev = mmc_get_env_dev();
const char *errmsg = NULL;
ALLOC_CACHE_ALIGN_BUFFER(env_t, tmp_env1, 1);
ALLOC_CACHE_ALIGN_BUFFER(env_t, tmp_env2, 1);
mmc = find_mmc_device(dev);
errmsg = init_mmc_for_env(mmc);
if (errmsg) {
ret = -EIO;
goto err;
}
if (mmc_get_env_addr(mmc, 0, &offset1) ||
mmc_get_env_addr(mmc, 1, &offset2)) {
ret = -EIO;
goto fini;
}
read1_fail = read_env(mmc, CONFIG_ENV_SIZE, offset1, tmp_env1);
read2_fail = read_env(mmc, CONFIG_ENV_SIZE, offset2, tmp_env2);
if (read1_fail && read2_fail)
puts("*** Error - No Valid Environment Area found\n");
else if (read1_fail || read2_fail)
puts("*** Warning - some problems detected "
"reading environment; recovered successfully\n");
if (read1_fail && read2_fail) {
errmsg = "!bad CRC";
ret = -EIO;
goto fini;
} else if (!read1_fail && read2_fail) {
gd->env_valid = ENV_VALID;
env_import((char *)tmp_env1, 1);
} else if (read1_fail && !read2_fail) {
gd->env_valid = ENV_REDUND;
env_import((char *)tmp_env2, 1);
} else {
env_import_redund((char *)tmp_env1, (char *)tmp_env2);
}
ret = 0;
fini:
fini_mmc_for_env(mmc);
err:
if (ret)
set_default_env(errmsg);
#endif
return ret;
}
int
main (int argc, char **argv)
{
int frequency, oversample, stereo;
struct song *song;
int index;
int c;
int opt, error_flag;
/* supposed to make wildcard expansion */
_wildcard(&argc,&argv);
signal (2, nextsong);
signal (3, goodbye);
printf("Tracker1 V0.91 for the SBOS2 package\n");
/* Read environment variables */
frequency = read_env ("FREQUENCY", 0);
oversample = read_env ("OVERSAMPLE", 1);
transpose = read_env ("TRANSPOSE", 0);
if (getenv ("MONO"))
pref.stereo = 0;
else if (getenv ("STEREO"))
pref.stereo = 1;
else
pref.stereo = DEFAULT_CHANNELS - 1;
pref.type = BOTH;
pref.repeats = 1;
pref.speed = 50;
pref.tolerate = 2;
pref.verbose = 0;
set_mix (DEFAULT_MIX); /* 0 = full stereo, 100 = mono */
error_flag = 0;
while ((opt = getopt_long_only (argc, argv, "", long_options, NULL)) != EOF)
{
switch (opt)
{
case 'H': /* help */
error_flag++;
break;
case 'Q': /* quiet */
quiet++;
break;
case 'P': /* abort on faults (be picky) */
pref.tolerate = 0;
break;
case 'N': /* new tracker type */
pref.type = NEW;
break;
case 'O': /* old tracker type */
pref.type = OLD;
break;
case 'B': /* both tracker types */
pref.type = BOTH;
break;
case 'M': /* mono */
pref.stereo = 0;
break;
case 'S': /* stereo */
pref.stereo = 1;
break;
case 'V':
pref.verbose = 1;
break;
case 'f': /* frequency */
frequency = atoi (optarg);
break;
case 'o': /* oversampling */
oversample = atoi (optarg);
break;
case 't': /* transpose half-steps*/
transpose = atoi (optarg);
break;
case 'r': /* number of repeats */
pref.repeats = atoi (optarg);
break;
case 's': /* speed */
pref.speed = atoi (optarg);
break;
case 'm': /* % of channel mix. 100=mono */
set_mix (atoi (optarg));
break;
default: /* ??? */
error_flag++;
break;
}
}
if (error_flag || !argv[optind])
{
fprintf (stderr, "Usage: %s " USAGE, argv[0]);
exit(1);
}
frequency = open_audio (frequency);
init_player (oversample, frequency);
while (argv[optind])
{
switch (pref.type)
{
case BOTH:
song = do_read_song (argv[optind], NEW);
if (!song)
song = do_read_song (argv[optind], OLD);
break;
case OLD:
song = do_read_song (argv[optind], pref.type);
break;
case NEW:
/* this is explicitly flagged as a new module,
* so we don't need to look for a signature.
*/
song = do_read_song (argv[optind], NEW_NO_CHECK);
break;
}
optind++;
if (song == NULL)
continue;
dump_song (song);
play_song (song, &pref);
release_song (song);
/* flush out anything remaining in DMA buffers */
flush_DMA_buffers();
}
close_audio ();
return 0;
}
int auth_mysql_setpass(const char *user, const char *pass,
const char *oldpass)
{
char *newpass_crypt;
char *sql_buf;
int rc=0;
char *clear_escaped;
char *crypt_escaped;
const char *clear_field =NULL,
*crypt_field =NULL,
*defdomain =NULL,
*where_clause =NULL,
*user_table =NULL,
*login_field =NULL,
*chpass_clause =NULL; /* [email protected] */
if (do_connect()) return (-1);
if (!(newpass_crypt=authcryptpasswd(pass, oldpass)))
return (-1);
clear_escaped=malloc(strlen(pass)*2+1);
if (!clear_escaped)
{
perror("malloc");
free(newpass_crypt);
return -1;
}
crypt_escaped=malloc(strlen(newpass_crypt)*2+1);
if (!crypt_escaped)
{
perror("malloc");
free(clear_escaped);
free(newpass_crypt);
return -1;
}
mysql_real_escape_string(mysql, clear_escaped, pass, strlen(pass));
mysql_real_escape_string(mysql, crypt_escaped,
newpass_crypt, strlen(newpass_crypt));
/* [email protected] */
chpass_clause=read_env("MYSQL_CHPASS_CLAUSE");
defdomain=read_env("DEFAULT_DOMAIN");
user_table=read_env("MYSQL_USER_TABLE");
if (!chpass_clause)
{
int has_domain=strchr(user, '@') != NULL;
char *username_escaped;
char dummy_buf[1];
size_t sql_buf_size;
username_escaped=malloc(strlen(user)*2+1);
if (!username_escaped)
{
perror("malloc");
free(clear_escaped);
free(crypt_escaped);
free(newpass_crypt);
return -1;
}
mysql_real_escape_string(mysql, username_escaped,
user, strlen(user));
login_field = read_env("MYSQL_LOGIN_FIELD");
if (!login_field) login_field = "id";
crypt_field=read_env("MYSQL_CRYPT_PWFIELD");
clear_field=read_env("MYSQL_CLEAR_PWFIELD");
where_clause=read_env("MYSQL_WHERE_CLAUSE");
if (!where_clause)
where_clause="";
if (!crypt_field)
crypt_field="";
if (!clear_field)
clear_field="";
if (!defdomain)
defdomain="";
#define DEFAULT_SETPASS_UPDATE \
"UPDATE %s SET %s%s%s%s %s %s%s%s%s WHERE %s='%s%s%s' %s%s%s", \
user_table, \
*clear_field ? clear_field:"", \
*clear_field ? "='":"", \
*clear_field ? clear_escaped:"", \
*clear_field ? "'":"", \
\
*clear_field && *crypt_field ? ",":"", \
\
*crypt_field ? crypt_field:"", \
*crypt_field ? "='":"", \
*crypt_field ? crypt_escaped:"", \
*crypt_field ? "'":"", \
login_field, \
username_escaped, \
has_domain || !*defdomain ? "":"@", \
has_domain ? "":defdomain, \
*where_clause ? " AND (":"", where_clause, \
*where_clause ? ")":""
sql_buf_size=snprintf(dummy_buf, 1, DEFAULT_SETPASS_UPDATE);
sql_buf=malloc(sql_buf_size+1);
if (sql_buf)
snprintf(sql_buf, sql_buf_size+1,
DEFAULT_SETPASS_UPDATE);
free(username_escaped);
}
else
{
sql_buf=parse_chpass_clause(chpass_clause,
user,
defdomain,
clear_escaped,
crypt_escaped);
}
free(clear_escaped);
free(crypt_escaped);
free(newpass_crypt);
if (courier_authdebug_login_level >= 2)
{
DPRINTF("setpass SQL: %s", sql_buf);
}
if (mysql_query (mysql, sql_buf))
{
DPRINTF("setpass SQL failed");
rc= -1;
auth_mysql_cleanup();
}
free(sql_buf);
return (rc);
}
struct authmysqluserinfo *auth_mysql_getuserinfo(const char *username,
const char *service)
{
const char *defdomain =NULL;
char *querybuf;
MYSQL_ROW row;
MYSQL_RES *result;
int num_fields;
char *endp;
const char *select_clause; /* [email protected] */
#define DEFAULT_SELECT_QUERY "SELECT %s, %s, %s, %s, %s, %s, %s, %s, %s, %s FROM %s WHERE %s = '%s%s%s' %s%s%s", \
login_field, crypt_field, clear_field, uid_field,\
gid_field, home_field, maildir_field, quota_field,\
name_field, options_field, user_table, login_field,\
username_escaped,\
has_domain || !*defdomain ? "":"@", has_domain ? "":defdomain, \
*where_clause ? " AND (":"", where_clause,\
*where_clause ? ")":""
if (do_connect()) return (0);
initui();
select_clause=read_env("MYSQL_SELECT_CLAUSE");
defdomain=read_env("DEFAULT_DOMAIN");
if (!defdomain) defdomain="";
if (!select_clause) /* [email protected] */
{
const char *user_table,
*crypt_field,
*clear_field,
*name_field,
*uid_field,
*gid_field,
*login_field,
*home_field,
*maildir_field,
*quota_field,
*options_field,
*where_clause;
char *username_escaped;
size_t query_size;
char dummy_buf[1];
int has_domain;
user_table=read_env("MYSQL_USER_TABLE");
if (!user_table)
{
err("authmysql: MYSQL_USER_TABLE not set in "
AUTHMYSQLRC ".");
return (0);
}
crypt_field=read_env("MYSQL_CRYPT_PWFIELD");
clear_field=read_env("MYSQL_CLEAR_PWFIELD");
name_field=read_env("MYSQL_NAME_FIELD");
if (!crypt_field && !clear_field)
{
err("authmysql: MYSQL_CRYPT_PWFIELD and "
"MYSQL_CLEAR_PWFIELD not set in " AUTHMYSQLRC ".");
return (0);
}
if (!crypt_field) crypt_field="\"\"";
if (!clear_field) clear_field="\"\"";
if (!name_field) name_field="\"\"";
uid_field = read_env("MYSQL_UID_FIELD");
if (!uid_field) uid_field = "uid";
gid_field = read_env("MYSQL_GID_FIELD");
if (!gid_field) gid_field = "gid";
login_field = read_env("MYSQL_LOGIN_FIELD");
if (!login_field) login_field = "id";
home_field = read_env("MYSQL_HOME_FIELD");
if (!home_field) home_field = "home";
maildir_field=read_env(service && strcmp(service, "courier")==0
? "MYSQL_DEFAULTDELIVERY"
: "MYSQL_MAILDIR_FIELD");
if (!maildir_field) maildir_field="\"\"";
quota_field=read_env("MYSQL_QUOTA_FIELD");
if (!quota_field) quota_field="\"\"";
options_field=read_env("MYSQL_AUXOPTIONS_FIELD");
if (!options_field) options_field="\"\"";
where_clause=read_env("MYSQL_WHERE_CLAUSE");
if (!where_clause) where_clause = "";
username_escaped=malloc(strlen(username)*2+1);
if (!username_escaped)
{
perror("malloc");
return (0);
}
mysql_real_escape_string(mysql, username_escaped,
username, strlen(username));
has_domain=strchr(username, '@') != NULL;
query_size=snprintf(dummy_buf, 1, DEFAULT_SELECT_QUERY);
querybuf=malloc(query_size+1);
if (!querybuf)
{
free(username_escaped);
perror("malloc");
return(0);
}
snprintf(querybuf, query_size+1, DEFAULT_SELECT_QUERY);
free(username_escaped);
}
else
{
/* [email protected] */
querybuf=parse_select_clause (select_clause, username,
defdomain, service);
if (!querybuf)
{
DPRINTF("parse_select_clause failed (DEFAULT_DOMAIN not set?)");
return 0;
}
}
DPRINTF("SQL query: %s", querybuf);
if (mysql_query (mysql, querybuf))
{
/* <*****@*****.**> */
DPRINTF("mysql_query failed, reconnecting: %s", mysql_error(mysql));
auth_mysql_cleanup();
if (do_connect())
{
free(querybuf);
return (0);
}
if (mysql_query (mysql, querybuf))
{
DPRINTF("mysql_query failed second time, giving up: %s", mysql_error(mysql));
free(querybuf);
auth_mysql_cleanup();
/* Server went down, that's OK,
** try again next time.
*/
return (0);
}
}
free(querybuf);
result = mysql_store_result (mysql);
if (result)
{
if (mysql_num_rows(result))
{
row = mysql_fetch_row (result);
num_fields = mysql_num_fields (result);
if (num_fields < 6)
{
DPRINTF("incomplete row, only %d fields returned",
num_fields);
mysql_free_result(result);
return(0);
}
if (row[0] && row[0][0])
ui.username=strdup(row[0]);
if (row[1] && row[1][0])
ui.cryptpw=strdup(row[1]);
if (row[2] && row[2][0])
ui.clearpw=strdup(row[2]);
/* perhaps authmysql needs a glob_uid/glob_gid feature
like authldap? */
if (!row[3] || !row[3][0] ||
(ui.uid=strtol(row[3], &endp, 10), endp[0] != '\0'))
{
DPRINTF("invalid value for uid: '%s'",
row[3] ? row[3] : "<null>");
mysql_free_result(result);
return 0;
}
if (!row[4] || !row[4][0] ||
(ui.gid=strtol(row[4], &endp, 10), endp[0] != '\0'))
{
DPRINTF("invalid value for gid: '%s'",
row[4] ? row[4] : "<null>");
mysql_free_result(result);
return 0;
}
if (row[5] && row[5][0])
ui.home=strdup(row[5]);
else
{
DPRINTF("required value for 'home' (column 6) is missing");
mysql_free_result(result);
return(0);
}
if (num_fields > 6 && row[6] && row[6][0])
ui.maildir=strdup(row[6]);
if (num_fields > 7 && row[7] && row[7][0])
ui.quota=strdup(row[7]);
if (num_fields > 8 && row[8] && row[8][0])
ui.fullname=strdup(row[8]);
if (num_fields > 9 && row[9] && row[9][0])
ui.options=strdup(row[9]);
}
else
{
DPRINTF("zero rows returned");
mysql_free_result(result);
return (&ui); /* User not found */
}
}
else
{
DPRINTF("mysql_store_result failed");
return (0);
}
mysql_free_result(result);
return (&ui);
}
static int do_connect()
{
const char *server;
const char *userid;
const char *password;
const char *database;
const char *server_socket=0;
unsigned int server_port=0;
unsigned int server_opt=0;
const char *p;
const char *sslkey;
const char *sslcert;
const char *sslcacert;
const char *sslcapath;
const char *sslcipher;
unsigned int use_ssl=0;
/*
** Periodically detect dead connections.
*/
if (mysql)
{
static time_t last_time=0;
time_t t_check;
time(&t_check);
if (t_check < last_time)
last_time=t_check; /* System clock changed */
if (t_check < last_time + 60)
return (0);
last_time=t_check;
if (mysql_ping(mysql) == 0) return (0);
DPRINTF("authmysqllib: mysql_ping failed, connection lost");
mysql_close(mysql);
mysql=0;
}
server=read_env("MYSQL_SERVER");
userid=read_env("MYSQL_USERNAME");
password=read_env("MYSQL_PASSWORD");
database=read_env("MYSQL_DATABASE");
#if MYSQL_VERSION_ID >= 32200
sslkey=read_env("MYSQL_SSL_KEY");
sslcert=read_env("MYSQL_SSL_CERT");
sslcacert=read_env("MYSQL_SSL_CACERT");
sslcapath=read_env("MYSQL_SSL_CAPATH");
sslcipher=read_env("MYSQL_SSL_CIPHER");
if ((sslcert != NULL) && ((sslcacert != NULL) || (sslcapath != NULL)))
{
use_ssl=1;
}
#endif
server_socket=(char *) read_env("MYSQL_SOCKET");
if ((p=read_env("MYSQL_PORT")) != 0)
{
server_port=(unsigned int) atoi(p);
}
if ((p=read_env("MYSQL_OPT")) != 0)
{
server_opt=(unsigned int) atol(p);
}
if (!server && !server_socket)
{
err("authmysql: MYSQL_SERVER nor MYSQL_SOCKET set in"
AUTHMYSQLRC ".");
return (-1);
}
if (!userid)
{
err("authmysql: MYSQL_USERNAME not set in "
AUTHMYSQLRC ".");
return (-1);
}
if (!database)
{
err("authmysql: MYSQL_DATABASE not set in "
AUTHMYSQLRC ".");
return (-1);
}
#if MYSQL_VERSION_ID >= 32200
mysql_init(&mysql_buf);
if (use_ssl)
{
mysql_ssl_set(&mysql_buf, sslkey, sslcert, sslcacert,
sslcapath, sslcipher);
}
mysql=mysql_real_connect(&mysql_buf, server, userid, password,
NULL,
server_port,
server_socket,
server_opt);
#else
mysql=mysql_connect(&mysql_buf, server, userid, password);
#endif
if (!mysql)
{
err("failed to connect to mysql server (server=%s, userid=%s): %s",
server ? server : "<null>",
userid ? userid : "<null>",
mysql_error(&mysql_buf));
return (-1);
}
if (mysql_select_db(mysql, database))
{
err("authmysql: mysql_select_db(%s) error: %s",
database, mysql_error(mysql));
mysql_close(mysql);
mysql=0;
return (-1);
}
DPRINTF("authmysqllib: connected. Versions: "
"header %lu, "
"client %lu, "
"server %lu",
(long)MYSQL_VERSION_ID,
mysql_get_client_version(),
mysql_get_server_version(mysql));
set_session_options();
return (0);
}
void auth_mysql_enumerate( void(*cb_func)(const char *name,
uid_t uid,
gid_t gid,
const char *homedir,
const char *maildir,
const char *options,
void *void_arg),
void *void_arg)
{
const char *defdomain, *select_clause;
char *querybuf;
MYSQL_ROW row;
MYSQL_RES *result;
if (do_connect()) return;
initui();
select_clause=read_env("MYSQL_ENUMERATE_CLAUSE");
defdomain=read_env("DEFAULT_DOMAIN");
if (!defdomain || !defdomain[0])
defdomain="*"; /* otherwise parse_select_clause fails */
if (!select_clause)
{
const char *user_table,
*uid_field,
*gid_field,
*login_field,
*home_field,
*maildir_field,
*options_field,
*where_clause;
char dummy_buf[1];
size_t query_len;
user_table=read_env("MYSQL_USER_TABLE");
if (!user_table)
{
err("authmysql: MYSQL_USER_TABLE not set in "
AUTHMYSQLRC ".");
return;
}
uid_field = read_env("MYSQL_UID_FIELD");
if (!uid_field) uid_field = "uid";
gid_field = read_env("MYSQL_GID_FIELD");
if (!gid_field) gid_field = "gid";
login_field = read_env("MYSQL_LOGIN_FIELD");
if (!login_field) login_field = "id";
home_field = read_env("MYSQL_HOME_FIELD");
if (!home_field) home_field = "home";
maildir_field=read_env("MYSQL_MAILDIR_FIELD");
if (!maildir_field) maildir_field="\"\"";
options_field=read_env("MYSQL_AUXOPTIONS_FIELD");
if (!options_field) options_field="\"\"";
where_clause=read_env("MYSQL_WHERE_CLAUSE");
if (!where_clause) where_clause = "";
#define DEFAULT_ENUMERATE_QUERY \
"SELECT %s, %s, %s, %s, %s, %s FROM %s %s%s",\
login_field, uid_field, gid_field, \
home_field, maildir_field, \
options_field, user_table, \
*where_clause ? " WHERE ":"", \
where_clause
query_len=snprintf(dummy_buf, 1, DEFAULT_ENUMERATE_QUERY);
querybuf=malloc(query_len+1);
if (!querybuf)
{
perror("malloc");
return;
}
snprintf(querybuf, query_len+1, DEFAULT_ENUMERATE_QUERY);
}
else
{
/* [email protected] */
querybuf=parse_select_clause (select_clause, "*",
defdomain, "enumerate");
if (!querybuf)
{
DPRINTF("authmysql: parse_select_clause failed");
return;
}
}
DPRINTF("authmysql: enumerate query: %s", querybuf);
if (mysql_query (mysql, querybuf))
{
DPRINTF("mysql_query failed, reconnecting: %s", mysql_error(mysql));
/* <*****@*****.**> */
auth_mysql_cleanup();
if (do_connect())
{
free(querybuf);
return;
}
if (mysql_query (mysql, querybuf))
{
DPRINTF("mysql_query failed second time, giving up: %s", mysql_error(mysql));
free(querybuf);
auth_mysql_cleanup();
return;
}
}
free(querybuf);
result = mysql_use_result (mysql);
if (result)
{
const char *username;
uid_t uid;
gid_t gid;
const char *homedir;
const char *maildir;
const char *options;
while ((row = mysql_fetch_row (result)) != NULL)
{
if(!row[0] || !row[0][0]
|| !row[1] || !row[1][0]
|| !row[2] || !row[2][0]
|| !row[3] || !row[3][0])
{
continue;
}
username=row[0];
uid=atol(row[1]); /* FIXME use strtol to validate */
gid=atol(row[2]);
homedir=row[3];
maildir=row[4];
options=row[5];
if (maildir && !*maildir)
maildir=NULL;
(*cb_func)(username, uid, gid, homedir,
maildir, options, void_arg);
}
}
/* NULL row could indicate end of result or an error */
if (mysql_errno(mysql))
{
DPRINTF("mysql error during enumeration: %s", mysql_error(mysql));
}
else
(*cb_func)(NULL, 0, 0, NULL, NULL, NULL, void_arg);
if (result) mysql_free_result(result);
}
