vmysql.c

相当优秀的 UNIX 进程管理工具

        int i;

        vdir->cur_users = 0;
        for(i=0;i<MAX_DIR_LEVELS;++i){
            vdir->level_start[i] = 0;
            vdir->level_end[i] = MAX_DIR_LIST-1;
            vdir->level_index[i] = 0;
        }
        vdir->level_mod[0] = 0;
        vdir->level_mod[1] = 2;
        vdir->level_mod[2] = 4;
        vdir->level_cur = 0;
        vdir->level_max = MAX_DIR_LEVELS;
        vdir->the_dir[0] = 0;
    }
    return(0);
}

int vwrite_dir_control(vdir_type *vdir, char *domain, uid_t uid, gid_t gid)
{
    if ( vauth_open_update() != 0 ) return(-1);

    qnprintf(SqlBufUpdate, SQL_BUF_SIZE, "replace into dir_control ( \
domain, cur_users, \
level_cur, level_max, \
level_start0, level_start1, level_start2, \
level_end0, level_end1, level_end2, \
level_mod0, level_mod1, level_mod2, \
level_index0, level_index1, level_index2, the_dir ) values ( \
'%s', %lu, %d, %d, \
%d, %d, %d, \
%d, %d, %d, \
%d, %d, %d, \
%d, %d, %d, \
'%s')\n",
    domain, vdir->cur_users, vdir->level_cur, vdir->level_max,
    vdir->level_start[0], vdir->level_start[1], vdir->level_start[2],
    vdir->level_end[0], vdir->level_end[1], vdir->level_end[2],
    vdir->level_mod[0], vdir->level_mod[1], vdir->level_mod[2],
    vdir->level_index[0], vdir->level_index[1], vdir->level_index[2],
    vdir->the_dir);

    if (mysql_query(&mysql_update,SqlBufUpdate)) {
        vcreate_dir_control(domain);
        if (mysql_query(&mysql_update,SqlBufUpdate)) {
            fprintf(stderr, "vmysql: sql error[b]: %s\n", mysql_error(&mysql_update));
            return(-1);
        }
    }

    return(0);
}

void vcreate_dir_control(char *domain)
{
  if (vauth_create_table ("dir_control", DIR_CONTROL_TABLE_LAYOUT, 1)) return;

    /* this next bit should be replaced with a call to vwrite_dir_control */
    qnprintf(SqlBufUpdate, SQL_BUF_SIZE, "replace into dir_control ( \
domain, cur_users, \
level_cur, level_max, \
level_start0, level_start1, level_start2, \
level_end0, level_end1, level_end2, \
level_mod0, level_mod1, level_mod2, \
level_index0, level_index1, level_index2, the_dir ) values ( \
'%s', 0, \
0, %d, \
0, 0, 0, \
%d, %d, %d, \
0, 2, 4, \
0, 0, 0, \
'')\n",
    domain, MAX_DIR_LEVELS, MAX_DIR_LIST-1, MAX_DIR_LIST-1, MAX_DIR_LIST-1);

    if (mysql_query(&mysql_update,SqlBufUpdate)) {
        fprintf(stderr, "vmysql: sql error[d]: %s\n", mysql_error(&mysql_update));
        return;
    }
}

int vdel_dir_control(char *domain)
{
 int err;

    if ( (err=vauth_open_update()) != 0 ) return(err);

    qnprintf(SqlBufUpdate, SQL_BUF_SIZE, 
        "delete from dir_control where domain = '%s'", 
        domain); 
    if (mysql_query(&mysql_update,SqlBufUpdate)) {
        vcreate_dir_control(domain);
            if (mysql_query(&mysql_update,SqlBufUpdate)) {
                fprintf(stderr, "vmysql: sql error[e]: %s\n", mysql_error(&mysql_update));
                return(-1);
        }
    }

    return(0);
}

#ifdef ENABLE_AUTH_LOGGING
int vset_lastauth(char *user, char *domain, char *remoteip )
{
 int err;

    if ( (err=vauth_open_update()) != 0 ) return(err);

    qnprintf( SqlBufUpdate, SQL_BUF_SIZE,
"replace into lastauth set user='%s', domain='%s', \
remote_ip='%s', timestamp=%lu", user, domain, remoteip, time(NULL)); 
    if (mysql_query(&mysql_update,SqlBufUpdate)) {
        vcreate_lastauth_table();
        if (mysql_query(&mysql_update,SqlBufUpdate)) {
            fprintf(stderr, "vmysql: sql error[f]: %s\n", mysql_error(&mysql_update));
        }
    }
    return(0);
}

time_t vget_lastauth(struct vqpasswd *pw, char *domain)
{
 int err;
 time_t mytime;

    if ( (err=vauth_open_read()) != 0 ) return(err);

    qnprintf( SqlBufRead,  SQL_BUF_SIZE,
    "select timestamp from lastauth where user='%s' and domain='%s'", 
        pw->pw_name, domain);
    if (mysql_query(&mysql_read,SqlBufRead)) {
        vcreate_lastauth_table();
        if (mysql_query(&mysql_read,SqlBufRead)) {
            fprintf(stderr, "vmysql: sql error[g]: %s\n", mysql_error(&mysql_read));
            return(0);
        }
    }
    res_read = mysql_store_result(&mysql_read);
    mytime = 0;
    while((row = mysql_fetch_row(res_read))) {
        mytime = atol(row[0]);
    }
    mysql_free_result(res_read);
    return(mytime);
}

char *vget_lastauthip(struct vqpasswd *pw, char *domain)
{
 static char tmpbuf[100];

    if ( vauth_open_read() != 0 ) return(NULL);

    qnprintf( SqlBufRead,  SQL_BUF_SIZE,
    "select remote_ip from lastauth where user='%s' and domain='%s'", 
        pw->pw_name, domain);
    if (mysql_query(&mysql_read,SqlBufRead)) {
        vcreate_lastauth_table();
        if (mysql_query(&mysql_read,SqlBufRead)) {
            fprintf(stderr, "vmysql: sql error[h]: %s\n", mysql_error(&mysql_read));
            return(NULL);
        }
    }
    res_read = mysql_store_result(&mysql_read);
    while((row = mysql_fetch_row(res_read))) {
        strncpy(tmpbuf,row[0],100);
    }
    mysql_free_result(res_read);
    return(tmpbuf);
}

void vcreate_lastauth_table()
{
  vauth_create_table ("lastauth", LASTAUTH_TABLE_LAYOUT, 1);
  return;
}
#endif /* ENABLE_AUTH_LOGGING */

#ifdef VALIAS
char *valias_select( char *alias, char *domain )
{
 int err;

    /* if we can not connect, set the verrori value */
    if ( (err=vauth_open_read()) != 0 ) {
      return(NULL);
    }

    qnprintf( SqlBufRead, SQL_BUF_SIZE, "select valias_line from valias \
where alias = '%s' and domain = '%s'", alias, domain );

    if (mysql_query(&mysql_read,SqlBufRead)) {
        vcreate_valias_table();
        if (mysql_query(&mysql_read,SqlBufRead)) {
            fprintf(stderr, "vmysql: sql error[j]: %s\n", mysql_error(&mysql_read));
            return(NULL);
        }
    }
    res_read = mysql_store_result(&mysql_read);
    return(valias_select_next());
}

char *valias_select_next()
{
    if((row = mysql_fetch_row(res_read))) {
        return(row[0]);
    }
    mysql_free_result(res_read);
    return(NULL);
}

int valias_insert( char *alias, char *domain, char *alias_line)
{
 int err;

    if ( (err=vauth_open_update()) != 0 ) return(err);
    while(*alias_line==' ' && *alias_line!=0) ++alias_line;

    qnprintf( SqlBufUpdate, SQL_BUF_SIZE, "insert into valias \
( alias, domain, valias_line ) values ( '%s', '%s', '%s')",
        alias, domain, alias_line );

    if (mysql_query(&mysql_update,SqlBufUpdate)) {
        vcreate_valias_table();
        if (mysql_query(&mysql_update,SqlBufUpdate)) {
            fprintf(stderr, "vmysql: sql error[k]: %s\n", mysql_error(&mysql_update));
            return(-1);
        }
    }
    return(0);
}

int valias_remove( char *alias, char *domain, char *alias_line)
{
 int err;

    if ( (err=vauth_open_update()) != 0 ) return(err);

    qnprintf( SqlBufUpdate, SQL_BUF_SIZE, 
        "delete from valias where alias = '%s' \
and valias_line = '%s' and domain = '%s'", alias, alias_line, domain );

    if (mysql_query(&mysql_update,SqlBufUpdate)) {
        vcreate_valias_table();
        if (mysql_query(&mysql_update,SqlBufUpdate)) {
            fprintf(stderr, "vmysql: sql error[l]: %s\n", mysql_error(&mysql_update));
            return(-1);
        }
    }
    return(0);
}

int valias_delete( char *alias, char *domain)
{
 int err;

    if ( (err=vauth_open_update()) != 0 ) return(err);

    qnprintf( SqlBufUpdate, SQL_BUF_SIZE, 
        "delete from valias where alias = '%s' \
and domain = '%s'", alias, domain );

    if (mysql_query(&mysql_update,SqlBufUpdate)) {
        vcreate_valias_table();
        if (mysql_query(&mysql_update,SqlBufUpdate)) {
            fprintf(stderr, "vmysql: sql error[l]: %s\n", mysql_error(&mysql_update));
            return(-1);
        }
    }
    return(0);
}

int valias_delete_domain( char *domain)
{
 int err;

    if ( (err=vauth_open_update()) != 0 ) return(err);

    qnprintf( SqlBufUpdate, SQL_BUF_SIZE, 
        "delete from valias where domain = '%s'", 
        domain );

    if (mysql_query(&mysql_update,SqlBufUpdate)) {
        vcreate_valias_table();
        if (mysql_query(&mysql_update,SqlBufUpdate)) {
            fprintf(stderr, "vmysql: sql error[m]: %s\n", mysql_error(&mysql_update));
            return(-1);
        }
    }
    return(0);
}

void vcreate_valias_table()
{
  vauth_create_table ("valias", VALIAS_TABLE_LAYOUT, 1);
  return;
}

char *valias_select_all( char *alias, char *domain )
{
 int err;

    if ( (err=vauth_open_read()) != 0 ) return(NULL);

    qnprintf( SqlBufRead, SQL_BUF_SIZE, 
        "select alias, valias_line from valias where domain = '%s' order by alias", domain );

    if (mysql_query(&mysql_read,SqlBufRead)) {
        vcreate_valias_table();
        if (mysql_query(&mysql_read,SqlBufRead)) {
            fprintf(stderr, "vmysql: sql error[o]: %s\n", mysql_error(&mysql_read));
            return(NULL);
        }
    }
    res_read = mysql_store_result(&mysql_read);
    return(valias_select_all_next(alias));
}

char *valias_select_all_next(char *alias)
{
    if((row = mysql_fetch_row(res_read))) {
        strcpy( alias, (row[0]));
        return(row[1]);
    }
    mysql_free_result(res_read);
    return(NULL);
}
#endif

#ifdef ENABLE_MYSQL_LOGGING
int logmysql(int verror, char *TheUser, char *TheDomain, char *ThePass, 
  char *TheName, char *IpAddr, char *LogLine) 
{
 int err;
 time_t mytime;
 

    mytime = time(NULL);
    if ( (err=vauth_open_update()) != 0 ) return(err);

    qnprintf( SqlBufUpdate, SQL_BUF_SIZE,
        "INSERT INTO vlog set user='%s', passwd='%s', \
        domain='%s', logon='%s', remoteip='%s', message='%s', \
        error=%i, timestamp=%d", TheUser, ThePass, TheDomain,
        TheName, IpAddr, LogLine, verror, (int)mytime);

    if (mysql_query(&mysql_update,SqlBufUpdate)) {
        vcreate_vlog_table();
        if (mysql_query(&mysql_update,SqlBufUpdate)) {
                fprintf(stderr, "error inserting into vlog table\n");
        }
    }
    return(0);
}


void vcreate_vlog_table()
{
  vauth_create_table ("vlog", VLOG_TABLE_LAYOUT, 1);
  return;
}
#endif

#ifdef ENABLE_MYSQL_LIMITS
void vcreate_limits_table()
{
  vauth_create_table ("limits", LIMITS_TABLE_LAYOUT, 1);
  return;
}

int vget_limits(const char *domain, struct vlimits *limits)
{
    vdefault_limits (limits);

    if (vauth_open_read() != 0)
         return(-1);

    qnprintf(SqlBufRead, SQL_BUF_SIZE, "SELECT maxpopaccounts, maxaliases, "
        "maxforwards, maxautoresponders, maxmailinglists, diskquota, "
        "maxmsgcount, defaultquota, defaultmaxmsgcount, "
        "disable_pop, disable_imap, disable_dialup, "
        "disable_passwordchanging, disable_webmail, disable_relay, "
        "disable_smtp, perm_account, perm_alias, perm_forward, "
        "perm_autoresponder, perm_maillist, perm_quota, perm_defaultquota \n"
        "FROM limits \n"
        "WHERE domain = '%s'", domain);


    if (mysql_query(&mysql_read,SqlBufRead)) {
        vcreate_limits_table();
        if (mysql_query(&mysql_read,SqlBufRead)) {
            fprintf(stderr, "vmysql: sql error[p]: %s\n", mysql_error(&mysql_read));
            return(-1);
        }
    }
    if (!(res_read = mysql_store_result(&mysql_read))) {
        fprintf(stderr, "vmysql: store result failed 7\n");
        return -1;
    }

    if (mysql_num_rows(res_read) == 0) {
        /* this should not be a fatal error: upgrading gets extremly annoying elsewise. */
        /*fprintf(stderr, "vmysql: can't find limits for domain '%s', using defaults.\n", domain);
        return -1;*/
        /* instead, we return the result of our attempt of reading the limits from the default limits file */
        return vlimits_read_limits_file (VLIMITS_DEFAULT_FILE, limits);

    } else if ((row = mysql_fetch_row(res_read)) != NULL) {
        int perm = atol(row[20]);

        limits->maxpopaccounts = atoi(row[0]);
        limits->maxaliases = atoi(row[1]);
        limits->maxforwards = atoi(row[2]);
        limits->maxautoresponders = atoi(row[3]);
        limits->maxmailinglists = atoi(row[4]);
        limits->diskquota = atoi(row[5]);
        limits->maxmsgcount = atoi(row[6]);
        limits->defaultquota = atoi(row[7]);
        limits->defaultmaxmsgcount = atoi(row[8]);
        limits->disable_pop = atoi(row[9]);
        limits->disable_imap = atoi(row[10]);
        limits->disable_dialup = atoi(row[11]);
        limits->disable_passwordchanging = atoi(row[12]);
        limits->disable_webmail = atoi(row[13]);
        limits->disable_relay = atoi(row[14]);
        limits->disable_smtp = atoi(row[15]);
        limits->perm_account = atoi(row[16]);
        limits->perm_alias = atoi(row[17]);
        limits->perm_forward = atoi(row[18]);
        limits->perm_autoresponder = atoi(row[19]);
        limits->perm_maillist = perm & VLIMIT_DISABLE_ALL;
        perm >>= VLIMIT_DISABLE_BITS;
        limits->perm_maillist_users = perm & VLIMIT_DISABLE_ALL;
        perm >>= VLIMIT_DISABLE_BITS;
        limits->perm_maillist_moderators = perm & VLIMIT_DISABLE_ALL;
        limits->perm_quota = atoi(row[21]);
        limits->perm_defaultquota = atoi(row[22]);
    }
    mysql_free_result(res_read);

    return 0;
}

int vset_limits(const char *domain, const struct vlimits *limits)
{
    if (vauth_open_update() != 0)
        return(-1);

    qnprintf(SqlBufUpdate, SQL_BUF_SIZE, "REPLACE INTO limits ("
        "domain, maxpopaccounts, maxaliases, "
        "maxforwards, maxautoresponders, maxmailinglists, "
        "diskquota, maxmsgcount, defaultquota, defaultmaxmsgcount, "
        "disable_pop, disable_imap, disable_dialup, "
        "disable_passwordchanging, disable_webmail, disable_relay, "
        "disable_smtp, perm_account, perm_alias, perm_forward, "
        "perm_autoresponder, perm_maillist, perm_quota, perm_defaultquota) \n"
        "VALUES \n"
        "('%s', %d, %d, %d, %d, %d, %d, %d, %d, %d, %d, %d, %d, %d, %d, %d, %d, %d, %d, %d, %d, %d, %d, %d)",
        domain,
        limits->maxpopaccounts,
        limits->maxaliases,
        limits->maxforwards,
        limits->maxautoresponders,
        limits->maxmailinglists,
        limits->diskquota,
        limits->maxmsgcount,
        limits->defaultquota,
        limits->defaultmaxmsgcount,
        limits->disable_pop,
        limits->disable_imap,
        limits->disable_dialup,
        limits->disable_passwordchanging,
        limits->disable_webmail,
        limits->disable_relay,
        limits->disable_smtp,
        limits->perm_account,
        limits->perm_alias,
        limits->perm_forward,
        limits->perm_autoresponder,
        (limits->perm_maillist |
         (limits->perm_maillist_users << VLIMIT_DISABLE_BITS) |
         (limits->perm_maillist_moderators << (VLIMIT_DISABLE_BITS * 2))),
        limits->perm_quota,
        limits->perm_defaultquota);

    if (mysql_query(&mysql_update,SqlBufUpdate)) {
        vcreate_limits_table();
        if (mysql_query(&mysql_update,SqlBufUpdate)) {
            fprintf(stderr, "vmysql: sql error[q]: %s\n", mysql_error(&mysql_update));
            return(-1);
        }
    }

    return 0;
}

int vdel_limits(const char *domain)
{
    qnprintf(SqlBufUpdate, SQL_BUF_SIZE, "DELETE FROM limits WHERE domain = '%s'", domain);

    if (mysql_query(&mysql_update,SqlBufUpdate))
        return(-1);
    return 0;
}

#endif

int vauth_crypt(char *user,char *domain,char *clear_pass,struct vqpasswd *vpw)
{
  if ( vpw == NULL ) return(-1);

  return(strcmp(crypt(clear_pass,vpw->pw_passwd),vpw->pw_passwd));
}