vmoddomlimits.c

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

                    case 'm': limits.perm_forward|=VLIMIT_DISABLE_MODIFY; break;
                    case 'd': limits.perm_forward|=VLIMIT_DISABLE_DELETE; break;
                }
            }
        }
        if (PermAutoresponderFlag == 1) {
            limits.perm_autoresponder=0;
            for (i=0; i<strlen(PermAutoresponderFlagString); i++) {
                switch(PermAutoresponderFlagString[i]) {
                    case 'a': limits.perm_autoresponder|=VLIMIT_DISABLE_ALL; break;
                    case 'c': limits.perm_autoresponder|=VLIMIT_DISABLE_CREATE; break;
                    case 'm': limits.perm_autoresponder|=VLIMIT_DISABLE_MODIFY; break;
                    case 'd': limits.perm_autoresponder|=VLIMIT_DISABLE_DELETE; break;
                }
            }
        }
        if (PermMaillistFlag == 1) {
            limits.perm_maillist=0;
            for (i=0; i<strlen(PermMaillistFlagString); i++) {
                switch(PermMaillistFlagString[i]) {
                    case 'a': limits.perm_maillist|=VLIMIT_DISABLE_ALL; break;
                    case 'c': limits.perm_maillist|=VLIMIT_DISABLE_CREATE; break;
                    case 'm': limits.perm_maillist|=VLIMIT_DISABLE_MODIFY; break;
                    case 'd': limits.perm_maillist|=VLIMIT_DISABLE_DELETE; break;
                }
            }
        }
        if (PermMaillistUsersFlag == 1) {
            limits.perm_maillist_users=0;
            for (i=0; i<strlen(PermMaillistUsersFlagString); i++) {
                switch(PermMaillistUsersFlagString[i]) {
                    case 'a': limits.perm_maillist_users|=VLIMIT_DISABLE_ALL; break;
                    case 'c': limits.perm_maillist_users|=VLIMIT_DISABLE_CREATE; break;
                    case 'm': limits.perm_maillist_users|=VLIMIT_DISABLE_MODIFY; break;
                    case 'd': limits.perm_maillist_users|=VLIMIT_DISABLE_DELETE; break;
                }
            }
        }
        if (PermMaillistModeratorsFlag == 1) {
            limits.perm_maillist_moderators=0;
            for (i=0; i<strlen(PermMaillistModeratorsFlagString); i++) {
                switch(PermMaillistModeratorsFlagString[i]) {
                    case 'a': limits.perm_maillist_moderators|=VLIMIT_DISABLE_ALL; break;
                    case 'c': limits.perm_maillist_moderators|=VLIMIT_DISABLE_CREATE; break;
                    case 'm': limits.perm_maillist_moderators|=VLIMIT_DISABLE_MODIFY; break;
                    case 'd': limits.perm_maillist_moderators|=VLIMIT_DISABLE_DELETE; break;
                }
            }
        }
        if (PermQuotaFlag == 1) {
            limits.perm_quota=0;
            for (i=0; i<strlen(PermQuotaFlagString); i++) {
                switch(PermQuotaFlagString[i]) {
                    case 'a': limits.perm_quota|=VLIMIT_DISABLE_ALL; break;
                    case 'c': limits.perm_quota|=VLIMIT_DISABLE_CREATE; break;
                    case 'm': limits.perm_quota|=VLIMIT_DISABLE_MODIFY; break;
                    case 'd': limits.perm_quota|=VLIMIT_DISABLE_DELETE; break;
                }
            }
        }
        if (PermDefaultQuotaFlag == 1) {
            limits.perm_defaultquota=0;
            for (i=0; i<strlen(PermDefaultQuotaFlagString); i++) {
                switch(PermDefaultQuotaFlagString[i]) {
                    case 'a': limits.perm_defaultquota|=VLIMIT_DISABLE_ALL; break;
                    case 'c': limits.perm_defaultquota|=VLIMIT_DISABLE_CREATE; break;
                    case 'm': limits.perm_defaultquota|=VLIMIT_DISABLE_MODIFY; break;
                    case 'd': limits.perm_defaultquota|=VLIMIT_DISABLE_DELETE; break;
                }
            }
        }
        if (EditDefaultLimits) {
            if (vlimits_write_limits_file(VLIMITS_DEFAULT_FILE, &limits)) {
            	printf ("Failed to write vlimits.default file");
            	return (vexit(-1));
            }
        } else {
            if (vset_limits(Domain,&limits) != 0) {
                printf ("Failed to vset_limits\n");
                return (vexit(-1));
            }
        }
    }
    
    return(vexit(0));

}

void usage()
{
    printf( "vmoddomlimits: usage: [options] domain \n");
    printf("options: -v ( display the vpopmail version number )\n");
    printf("         -d ( use the vlimits.default file, instead of domain )\n");
    printf("         -S ( show current settings )\n");
    printf("         -D ( delete limits for this domain, i.e. switch to default limits)\n");
    printf("         -Q quota-in-megabytes ( set domain disk quota, '100' = 100 MB )\n");
    printf("         -q quota-in-bytes ( set default user quota, '10M' = 10 MB )\n");
    printf("         -M count ( set domain max msg count )\n");
    printf("         -m count ( set default user max msg count )\n");
    printf("         -P count ( set max amount of pop accounts )\n");
    printf("         -A count ( set max amount of aliases )\n");
    printf("         -F count ( set max amount of forwards )\n");
    printf("         -R count ( set max amount of autoresponders )\n");
    printf("         -L count ( set max amount of mailing lists )\n");
    

    printf("the following options are bit flags in the gid int field\n");
    printf("         -g \"flags\"  (set flags, see below)\n");
    printf("         gid flags:\n");
    printf("            u ( set no dialup flag )\n");
    printf("            d ( set no password changing flag )\n");
    printf("            p ( set no pop access flag )\n");
    printf("            s ( set no smtp access flag )\n");
    printf("            w ( set no web mail access flag )\n");
    printf("            i ( set no imap access flag )\n");
    printf("            r ( set no external relay flag )\n");
    
    printf("the following options are bit flags for non postmaster admins\n");
    printf("         -p \"flags\"  (set pop account flags)\n");
    printf("         -a \"flags\"  (set alias flags)\n");
    printf("         -f \"flags\"  (set forward flags)\n");
    printf("         -r \"flags\"  (set autoresponder flags)\n");
    printf("         -l \"flags\"  (set mailinglist flags)\n");
    printf("         -u \"flags\"  (set mailinglist users flags)\n");
    printf("         -o \"flags\"  (set mailinglist moderators flags)\n");
    printf("         -x \"flags\"  (set quota flags)\n");
    printf("         -z \"flags\"  (set default quota flags)\n");
    printf("         perm flags:\n");
    printf("            a ( set deny all flag )\n");
    printf("            c ( set deny create flag )\n");
    printf("            m ( set deny modify flag )\n");
    printf("            d ( set deny delete flag )\n");
                
}

void get_options(int argc,char **argv)
{
 int c;
 int errflag;
 extern char *optarg;
 extern int optind;

    memset(Domain, 0, sizeof(Domain));
    memset(DomainQuota, 0, sizeof(DomainQuota));
    memset(DefaultUserQuota, 0, sizeof(DefaultUserQuota));
    memset(DomainMaxMsgCount, 0, sizeof(DomainMaxMsgCount));
    memset(DefaultUserMaxMsgCount, 0, sizeof(DefaultUserMaxMsgCount));
    memset(MaxPopAccounts, 0, sizeof(MaxPopAccounts));
    memset(MaxAliases, 0, sizeof(MaxAliases));
    memset(MaxForwards, 0, sizeof(MaxForwards));
    memset(MaxAutoresponders, 0, sizeof(MaxAutoresponders));
    memset(MaxMailinglists, 0, sizeof(MaxMailinglists));
    memset(GidFlagString, 0, sizeof(GidFlagString));
    
    memset(PermAccountFlagString,0, sizeof(PermAccountFlagString));
    memset(PermAliasFlagString,0, sizeof(PermAliasFlagString));
    memset(PermForwardFlagString,0, sizeof(PermForwardFlagString));
    memset(PermAutoresponderFlagString,0, sizeof(PermAutoresponderFlagString));
    memset(PermMaillistFlagString,0, sizeof(PermMaillistFlagString));
    memset(PermMaillistUsersFlagString,0, sizeof(PermMaillistUsersFlagString));
    memset(PermMaillistModeratorsFlagString,0, sizeof(PermMaillistModeratorsFlagString));
    memset(PermQuotaFlagString,0, sizeof(PermQuotaFlagString));
    memset(PermDefaultQuotaFlagString,0, sizeof(PermDefaultQuotaFlagString));
    
    QuotaFlag = 0;
    GidFlag = 0;
    PermAccountFlag = 0;
    PermAliasFlag = 0;
    PermForwardFlag = 0;
    PermAutoresponderFlag = 0;
    PermMaillistFlag = 0;
    PermMaillistUsersFlag = 0;
    PermMaillistModeratorsFlag = 0;
    PermQuotaFlag = 0;
    PermDefaultQuotaFlag = 0;
    //NoMakeIndex = 0;
    ShowLimits = 0;
    DeleteLimits = 0;
    EditDefaultLimits = 0;
    errflag = 0;
    while( (c=getopt(argc,argv,"vSDdQ:q:M:m:P:A:F:R:L:g:p:a:f:r:l:u:o:x:z:h")) != -1 ) {
        switch(c) {
            case 'v':
                printf("version: %s\n", VERSION);
                break;
            case 'S':
                ShowLimits = 1;
                break;
            case 'D':
                DeleteLimits = 1;
                break;
            case 'd':
                EditDefaultLimits = 1;
                snprintf(Domain, sizeof(Domain), "Default limits: %s", VLIMITS_DEFAULT_FILE);
            case 'Q':
                snprintf(DomainQuota, sizeof(DomainQuota), "%s", optarg);
                break;
            case 'q':
                snprintf(DefaultUserQuota, sizeof(DefaultUserQuota), "%s", optarg);
                break;
            case 'M':
                snprintf(DomainMaxMsgCount, sizeof(DomainMaxMsgCount), "%s", optarg);
                break;
            case 'm':
                snprintf(DefaultUserMaxMsgCount, sizeof(DefaultUserMaxMsgCount), "%s", optarg);
                break;
            case 'P':
                snprintf(MaxPopAccounts, sizeof(MaxPopAccounts), "%s", optarg);
                break;
            case 'A':
                snprintf(MaxAliases, sizeof(MaxAliases), "%s", optarg);
                break;
            case 'F':
                snprintf(MaxForwards, sizeof(MaxForwards), "%s", optarg);
                break;
            case 'R':
                snprintf(MaxAutoresponders, sizeof(MaxAutoresponders), "%s", optarg);
                break;
            case 'L':
                snprintf(MaxMailinglists, sizeof(MaxMailinglists), "%s", optarg);
                break;
            case 'g':
                snprintf(GidFlagString, sizeof(GidFlagString), "%s", optarg);
                GidFlag = 1;
                break;
            case 'p':
                snprintf(PermAccountFlagString, sizeof(PermAccountFlagString), "%s", optarg);
                PermAccountFlag = 1;
                break;
            case 'a':
                snprintf(PermAliasFlagString, sizeof(PermAliasFlagString), "%s", optarg);
                PermAliasFlag = 1;
                break;
            case 'f':
                snprintf(PermForwardFlagString, sizeof(PermForwardFlagString), "%s", optarg);
                PermForwardFlag = 1;
                break;
            case 'r':
                snprintf(PermAutoresponderFlagString, sizeof(PermAutoresponderFlagString), "%s", optarg);
                PermAutoresponderFlag = 1;
                break;
            case 'l':
                snprintf(PermMaillistFlagString, sizeof(PermMaillistFlagString), "%s", optarg);
                PermMaillistFlag = 1;
                break;
            case 'u':
                snprintf(PermMaillistUsersFlagString, sizeof(PermMaillistUsersFlagString), "%s", optarg);
                PermMaillistUsersFlag = 1;
                break;
            case 'o':
                snprintf(PermMaillistModeratorsFlagString, sizeof(PermMaillistModeratorsFlagString), "%s", optarg);
                PermMaillistModeratorsFlag = 1;
                break;
            case 'x':
                snprintf(PermQuotaFlagString, sizeof(PermQuotaFlagString), "%s", optarg);
                PermQuotaFlag = 1;
                break;
            case 'z':
                snprintf(PermDefaultQuotaFlagString, sizeof(PermDefaultQuotaFlagString), "%s", optarg);
                PermDefaultQuotaFlag = 1;
                break;
            case 'h':
                usage();
                vexit(0);
            default:
                errflag = 1;
                break;
        }
    }

    if ( optind < argc && EditDefaultLimits == 0) {
        snprintf(Domain, sizeof(Domain), "%s", argv[optind]);
        ++optind;
    }

    if ( Domain[0] == 0 && EditDefaultLimits == 0) { 
        usage();
        vexit(-1);
    }
}