Changeset 2642 for neercs/trunk


Ignore:
Timestamp:
Aug 2, 2008, 1:32:35 PM (12 years ago)
Author:
Jean-Yves Lamoureux
Message:
  • Moved most of the command line parsing to its own function
Location:
neercs/trunk/src
Files:
3 edited

Legend:

Unmodified
Added
Removed
  • neercs/trunk/src/main.c

    r2641 r2642  
    8080{
    8181    struct screen_list *screen_list = NULL;
    82     struct passwd *user_info;
    83     char *user_path = NULL, *user_dir = NULL;
    8482    int i, args, s=0;
    8583    long long unsigned int last_key_time = 0;
    8684    int mainret = -1;
    87     int attach = 0, forceattach = 0;
    88     int *to_grab = NULL;
    89     char **to_start = NULL;
    90     int nb_to_grab = 0;
     85
    9186
    9287    screen_list = create_screen_list();
     
    10398        args = 1;
    10499
    105     /* Build local config file path */
    106     user_dir = getenv("HOME");
    107     if(!user_dir)
    108     {
    109         user_info = getpwuid(getuid());
    110         if(user_info)
    111         {
    112             user_dir = user_info->pw_dir;
    113         }
    114     }
    115     if(user_dir)
    116     {
    117         user_path = malloc(strlen(user_dir) + strlen("/.neercsrc") + 1);
    118         sprintf(user_path, "%s/%s", user_dir, ".neercsrc");
    119     }
    120 
    121 
    122     screen_list->recurrent_list = (struct recurrent_list*) malloc(sizeof(struct recurrent_list));
    123     screen_list->recurrent_list->recurrent = (struct recurrent**) malloc(sizeof(struct recurrent*));
    124     if(!screen_list->recurrent_list->recurrent)
    125     {
    126         fprintf(stderr, "Can't allocate memory at %s:%d\n", __FUNCTION__, __LINE__);
    127         goto end;
    128     }
    129     screen_list->recurrent_list->count = 0;
    130 
    131     for(;;)
    132     {
    133         int option_index = 0;
    134         int pidopt;
    135         static struct myoption long_options[] =
    136             {
    137                 { "config",      1, NULL, 'c' },
    138 #if defined USE_GRAB
    139                 { "pid",         1, NULL, 'P' },
    140 #endif
    141                 { "help",        0, NULL, 'h' },
    142                 { "version",     0, NULL, 'v' },
    143             };
    144 #if defined USE_GRAB
    145         int c = mygetopt(argc, argv, "c:S:R::r::P:hv", long_options, &option_index);
    146 #else
    147         int c = mygetopt(argc, argv, "c:S:R::r::hv", long_options, &option_index);
    148 #endif
    149         if(c == -1)
    150             break;
    151 
    152         switch(c)
    153         {
    154         case 'c': /* --config */
    155             if(user_path)
    156                 free(user_path);
    157             user_path = strdup(myoptarg);
    158             s+=2;
    159             break;
    160         case 'S':
    161             if(!screen_list->session_name)
    162                 screen_list->session_name = strdup(myoptarg);
    163             s+=2;
    164             break;
    165         case 'P': /* --pid */
    166             pidopt = atoi(myoptarg);
    167             if(pidopt <= 0)
    168             {
    169                 fprintf(stderr, "Invalid pid %d\n", pidopt);
    170                 if(to_grab)
    171                     free(to_grab);
    172                 return -1;
    173             }
    174             if(!to_grab)
    175             {
    176                 /* At most argc-1-s times -P <pid> + final 0 */
    177                 to_grab = (int *)malloc(((argc-1-s)/2+1)*sizeof(int));
    178                 if(!to_grab)
    179                 {
    180                     fprintf(stderr, "Can't allocate memory at %s:%d\n", __FUNCTION__, __LINE__);
    181                     goto end;
    182                 }
    183             }
    184             to_grab[nb_to_grab++] = pidopt;
    185             to_grab[nb_to_grab] = 0;
    186             s+=2;
    187             break;
    188         case 'r':
    189             forceattach = 1;
    190         case 'R':
    191             if(attach)
    192             {
    193                 fprintf(stderr, "Attaching can only be requested once\n");
    194                 goto end;
    195             }
    196             if(myoptarg)
    197             {
    198                 if(screen_list->session_name)
    199                     free(screen_list->session_name);
    200                 screen_list->session_name = strdup(myoptarg);
    201                 s+=1;
    202             }
    203             attach = 1;
    204             s+=1;
    205             break;
    206         case 'h': /* --help */
    207             usage(argc, argv);
    208             mainret = 0;
    209             goto end;
    210             break;
    211         case 'v': /* --version */
    212             version();
    213             mainret = 0;
    214             goto end;
    215             break;
    216         default:
    217             fprintf(stderr, "Unknown argument #%d\n", myoptind);
    218             goto end;
    219             break;
    220         }
    221     }
     100
     101    s = handle_command_line(argc, argv, screen_list);
     102    if(s<0) goto end;
    222103
    223104    if(s < argc - 1)
    224105    {
    225         to_start = (char**)malloc((argc-s)*sizeof(char*));
    226         if(!to_start)
     106        screen_list->to_start = (char**)malloc((argc-s)*sizeof(char*));
     107        if(!screen_list->to_start)
    227108        {
    228109            fprintf(stderr, "Can't allocate memory at %s:%d\n", __FUNCTION__, __LINE__);
     
    231112        for(i=0; i<(argc-1) - s; i++)
    232113        {
    233             to_start[i] = strdup(argv[i+s+1]);
    234         }
    235         to_start[argc-1-s] = NULL;
     114            screen_list->to_start[i] = strdup(argv[i+s+1]);
     115        }
     116        screen_list->to_start[argc-1-s] = NULL;
    236117    }
    237118
     
    240121
    241122    /* Then local one  */
    242     if(user_path)
    243     {
    244         read_configuration_file(user_path, screen_list);
    245         free(user_path);
    246     }
    247 
    248     if(attach)
     123    if(screen_list->user_path)
     124    {
     125        read_configuration_file(screen_list->user_path, screen_list);
     126        free(screen_list->user_path);
     127    }
     128
     129    if(screen_list->attach)
    249130    {
    250131        char **sockets;
    251         if(nb_to_grab || (argc-1 > s))
     132        if(screen_list->nb_to_grab || (argc-1 > s))
    252133        {
    253134            fprintf(stderr, "-R can not be associated with commands or pids!\n");
     
    293174                free(screen_list->socket_path[SOCK_SERVER]);
    294175                screen_list->socket_path[SOCK_SERVER] = NULL;
    295                 attach = 0;
     176                screen_list->attach = 0;
    296177            }
    297178            for(i=0; sockets[i]; i++)
     
    302183        {
    303184            fprintf(stderr, "No socket found!\n");
    304             attach = 0;
    305         }
    306         if(forceattach && !attach)
     185            screen_list->attach = 0;
     186        }
     187        if(screen_list->forceattach && !screen_list->attach)
    307188            goto end;
    308189    }
     
    330211
    331212    /* Fork the server if needed */
    332     if(!attach)
    333     {
    334         if(start_server(to_grab, to_start, screen_list))
     213    if(!screen_list->attach)
     214    {
     215        if(start_server(screen_list->to_grab, screen_list->to_start, screen_list))
    335216            goto end;
    336217    }
     
    344225        ssize_t n;
    345226        char buf[128*1024];
    346 
     227        if(!screen_list) goto end;
    347228        if (screen_list->socket[SOCK_CLIENT] && (n = read(screen_list->socket[SOCK_CLIENT], buf, sizeof(buf)-1)) > 0)
    348229        {
     
    458339
    459340    struct screen_list *screen_list = NULL;
     341    struct passwd *user_info;
     342    char *user_dir = NULL;
    460343
    461344    /* Create screen list */
     
    496379    screen_list->session_name  = NULL;
    497380    screen_list->default_shell = NULL;
    498 
     381    screen_list->user_path     = NULL;
    499382    screen_list->autolock_timeout = -1;
     383    screen_list->to_grab = NULL;
     384    screen_list->to_start = NULL;
     385    screen_list->nb_to_grab = 0;
     386    screen_list->attach = 0;
     387    screen_list->forceattach = 0;
    500388
    501389
     
    507395    memset(screen_list->lockpass, 0, 1024);
    508396
     397
     398
     399    /* Build local config file path */
     400    user_dir = getenv("HOME");
     401    if(!user_dir)
     402    {
     403        user_info = getpwuid(getuid());
     404        if(user_info)
     405        {
     406            user_dir = user_info->pw_dir;
     407        }
     408    }
     409    if(user_dir)
     410    {
     411        screen_list->user_path = malloc(strlen(user_dir) + strlen("/.neercsrc") + 1);
     412        sprintf(screen_list->user_path, "%s/%s", user_dir, ".neercsrc");
     413    }
     414
     415
     416    screen_list->recurrent_list = (struct recurrent_list*) malloc(sizeof(struct recurrent_list));
     417    screen_list->recurrent_list->recurrent = (struct recurrent**) malloc(sizeof(struct recurrent*));
     418    if(!screen_list->recurrent_list->recurrent)
     419    {
     420        fprintf(stderr, "Can't allocate memory at %s:%d\n", __FUNCTION__, __LINE__);
     421        free(screen_list);
     422        free(screen_list->screen);
     423        return NULL;
     424    }
     425    screen_list->recurrent_list->count = 0;
     426
     427
     428
    509429    return screen_list;
    510430}
     431
     432
     433
     434int handle_command_line(int argc, char *argv[], struct screen_list *screen_list)
     435{
     436    int s = 0;
     437    for(;;)
     438    {
     439        int option_index = 0;
     440        int pidopt;
     441        static struct myoption long_options[] =
     442            {
     443                { "config",      1, NULL, 'c' },
     444#if defined USE_GRAB
     445                { "pid",         1, NULL, 'P' },
     446#endif
     447                { "help",        0, NULL, 'h' },
     448                { "version",     0, NULL, 'v' },
     449            };
     450#if defined USE_GRAB
     451        int c = mygetopt(argc, argv, "c:S:R::r::P:hv", long_options, &option_index);
     452#else
     453        int c = mygetopt(argc, argv, "c:S:R::r::hv", long_options, &option_index);
     454#endif
     455        if(c == -1)
     456            break;
     457
     458        switch(c)
     459        {
     460        case 'c': /* --config */
     461            if(screen_list->user_path)
     462                free(screen_list->user_path);
     463            screen_list->user_path = strdup(myoptarg);
     464            s+=2;
     465            break;
     466        case 'S':
     467            if(!screen_list->session_name)
     468                screen_list->session_name = strdup(myoptarg);
     469            s+=2;
     470            break;
     471        case 'P': /* --pid */
     472            pidopt = atoi(myoptarg);
     473            if(pidopt <= 0)
     474            {
     475                fprintf(stderr, "Invalid pid %d\n", pidopt);
     476                if(screen_list->to_grab)
     477                    free(screen_list->to_grab);
     478                return -1;
     479            }
     480            if(!screen_list->to_grab)
     481            {
     482                /* At most argc-1-s times -P <pid> + final 0 */
     483                screen_list->to_grab = (int *)malloc(((argc-1-s)/2+1)*sizeof(int));
     484                if(!screen_list->to_grab)
     485                {
     486                    fprintf(stderr, "Can't allocate memory at %s:%d\n", __FUNCTION__, __LINE__);
     487                    return -1;
     488                }
     489            }
     490            screen_list->to_grab[screen_list->nb_to_grab++] = pidopt;
     491            screen_list->to_grab[screen_list->nb_to_grab] = 0;
     492            s+=2;
     493            break;
     494        case 'r':
     495            screen_list->forceattach = 1;
     496        case 'R':
     497            if(screen_list->attach)
     498            {
     499                fprintf(stderr, "Attaching can only be requested once\n");
     500                return -1;
     501            }
     502            if(myoptarg)
     503            {
     504                if(screen_list->session_name)
     505                    free(screen_list->session_name);
     506                screen_list->session_name = strdup(myoptarg);
     507                s+=1;
     508            }
     509            screen_list->attach = 1;
     510            s+=1;
     511            break;
     512        case 'h': /* --help */
     513            usage(argc, argv);
     514            return -1;
     515            break;
     516        case 'v': /* --version */
     517            version();
     518            return -1;
     519            break;
     520        default:
     521            fprintf(stderr, "Unknown argument #%d\n", myoptind);
     522            return -1;
     523            break;
     524        }
     525    }
     526    return s;
     527}
  • neercs/trunk/src/neercs.h

    r2641 r2642  
    182182    struct screen **screen;      /* Windows */
    183183
     184    /* Option parsing and configuration */
    184185    struct option *config;
    185186    char *default_shell;
    186187    struct recurrent_list *recurrent_list;
     188    char *user_path;
     189    int *to_grab;
     190    char **to_start;
     191    int nb_to_grab;
     192    int attach, forceattach;
    187193
    188194    cucul_canvas_t *cv;
     
    210216void usage(int argc, char **argv);
    211217
     218int handle_command_line(int argc, char *argv[], struct screen_list *screen_list);
    212219
    213220struct screen_list *create_screen_list(void);
  • neercs/trunk/src/server.c

    r2641 r2642  
    388388    if(screen_list->recurrent_list)            free(screen_list->recurrent_list);
    389389
    390     if(screen_list->session_name)
     390    if(screen_list->session_name) {
    391391        free(screen_list->session_name);
    392 
    393     if(screen_list)
     392        screen_list->session_name = NULL;
     393    }
     394
     395    if(screen_list) {
    394396        free(screen_list);
     397        screen_list = NULL;
     398    }
    395399
    396400    return mainret;
Note: See TracChangeset for help on using the changeset viewer.