/*

  *  Copyright (C) 2001 - 2007 Tomasz Kojm <tkojm@clamav.net>

  *
  *  This program is free software; you can redistribute it and/or modify

  *  it under the terms of the GNU General Public License version 2 as
  *  published by the Free Software Foundation.

  *
  *  This program is distributed in the hope that it will be useful,
  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  *  GNU General Public License for more details.
  *
  *  You should have received a copy of the GNU General Public License
  *  along with this program; if not, write to the Free Software
  *  Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston,
  *  MA 02110-1301, USA.
  *
  */
 
 #if HAVE_CONFIG_H
 #include "clamav-config.h"
 #endif
 
 #include <stdio.h>
 #include <stdlib.h>
 #include <string.h>
 #define _GNU_SOURCE
 #include "getopt.h"
 
 #include "options.h"
 #include "output.h"
 
 

 static int register_option(struct optstruct *opt, const char *optlong, char optshort, const struct option *options_long, const char * const *accepted_long)

 {
 	struct optnode *newnode;
 	int i, found = 0;
 	const char *longname = NULL;
 
 
     if(optshort) {
 	for(i = 0; options_long[i].name; i++) {
 	    if(options_long[i].val == optshort) {
 		longname = options_long[i].name;
 		break;
 	    }
 	}
     } else
 	longname = optlong;
 
     if(!longname) {
 	mprintf("!register_option: No long option for -%c\n", optshort);
 	return -1;
     }
 
     if(accepted_long) {
 	for(i = 0; accepted_long[i]; i++)
 	    if(!strcmp(accepted_long[i], longname))
 		found = 1;
 
 	if(!found) {

 	    if(optshort)
 		mprintf("WARNING: Ignoring option --%s (-%c)\n", longname, optshort);
 	    else
 		mprintf("WARNING: Ignoring option --%s\n", longname);
 

 	    return 0;
 	}
     }
 

     newnode = (struct optnode *) malloc(sizeof(struct optnode));

     if(!newnode) {

 	mprintf("!register_long_option: malloc failed\n");

 	return -1;
     }
 
     newnode->optshort = optshort;
 
     if(optarg) {

 	newnode->optarg = (char *) malloc(strlen(optarg) + 1);

 	if(!newnode->optarg) {

 	    mprintf("!register_long_option: malloc failed\n");

 	    free(newnode);
 	    return -1;
 	}
 	strcpy(newnode->optarg, optarg);
     } else
 	newnode->optarg = NULL;
 

     newnode->optlong = (char *) malloc(strlen(longname) + 1);

     if(!newnode->optlong) {

 	mprintf("ERROR: register_long_option: malloc failed\n");

 	free(newnode->optarg);
 	free(newnode);
 	return -1;
     }
     strcpy(newnode->optlong, longname);
 
     newnode->next = opt->optlist;
     opt->optlist = newnode;
     return 0;
 }
 
 void opt_free(struct optstruct *opt)
 {
 	struct optnode *handler, *prev;
 
     if(!opt)
 	return;
 
     handler = opt->optlist;
     while(handler) {
 	if(handler->optarg)
 	    free(handler->optarg);
 	if(handler->optlong)
 	    free(handler->optlong);
 	prev = handler;
 	handler = handler->next;
 	free(prev);
     }
 
     if(opt->filename)
     	free(opt->filename);
 
     free(opt);
 }
 

 struct optstruct *opt_parse(int argc, char * const *argv, const char *getopt_short, const struct option *options_long, const char * const *accepted_long)

 {
 	int ret, opt_index, i, len;
 	struct optstruct *opt;
 	const char *longname;
 
 

     opt = (struct optstruct *) calloc(1, sizeof(struct optstruct));

     if(!opt) {

 	mprintf("!opt_parse: calloc failed\n");

 	return NULL;
     }
 
     while(1) {
 	opt_index = 0;
 	ret = getopt_long(argc, argv, getopt_short, options_long, &opt_index);
 
 	if(ret == -1)
 	    break;
 
 	switch(ret) {
 	    case 0:
 		if(register_option(opt, options_long[opt_index].name, 0, options_long, accepted_long) == -1) {
 		    opt_free(opt);
 		    return NULL;
 		}
 		break;
 
     	    default:
 		if(strchr(getopt_short, ret)) {
 		    if(opt_index)
 			longname = options_long[opt_index].name;
 		    else
 			longname = NULL;
 

 		    if(register_option(opt, longname, ret, options_long, accepted_long) == -1) {

 			opt_free(opt);
 			return NULL;
 		    }
 
 		} else {
 		    mprintf("!Unknown option passed.\n");
 		    opt_free(opt);
 		    return NULL;
 		}
 	}
     }
 
     if(optind < argc) {
         len = 0;
 
 	/* count length of non-option arguments */
 	for(i = optind; i < argc; i++)
 	    len += strlen(argv[i]);
 
 	len += argc - optind - 1;

 	opt->filename = (char *) calloc(len + 64, sizeof(char));

 	if(!opt->filename) {

 	    mprintf("!opt_parse: calloc failed\n");

 	    opt_free(opt);
 	    return NULL;
 	}
 
         for(i = optind; i < argc; i++) {
 	    strncat(opt->filename, argv[i], strlen(argv[i]));
 	    if(i != argc - 1)
 		strncat(opt->filename, "\t", 1);
 	}
     }
 
     return opt;
 }
 

 int opt_check(const struct optstruct *opt, const char *optlong)

 {
 	struct optnode *handler;
 
     if(!opt) {
 	mprintf("!opt_check: opt == NULL\n");
 	return 0;
     }
 
     handler = opt->optlist;
 
     while(handler) {
 	if(handler->optlong && !strcmp(handler->optlong, optlong))
 	    return 1;
 
 	handler = handler->next;
     }
 
     return 0;
 }
 

 char *opt_arg(const struct optstruct *opt, const char *optlong)

 {
 	struct optnode *handler;
 
     if(!opt) {
 	mprintf("!opt_arg: opt == NULL\n");
 	return 0;
     }
 
     handler = opt->optlist;
 
     while(handler) {
 	if(handler->optlong && !strcmp(handler->optlong, optlong))
 	    return handler->optarg;
 
 	handler = handler->next;
     }
 
     return NULL;
 }
 
 char *opt_firstarg(const struct optstruct *opt, const char *optlong, const struct optnode **optnode)
 {

 	const struct optnode *handler;

 
     if(!opt) {
 	mprintf("!opt_firstarg: opt == NULL\n");
 	return 0;
     }
 
     handler = opt->optlist;
 
     while(handler) {
 	if(handler->optlong && !strcmp(handler->optlong, optlong)) {
 	    *optnode = handler;
 	    return handler->optarg;
 	}
 	handler = handler->next;
     }
 
     *optnode = NULL;
     return NULL;
 }
 
 char *opt_nextarg(const struct optnode **optnode, const char *optlong)
 {
 	struct optnode *handler;
 
     if(!optnode || !*optnode) {
 	mprintf("!opt_nextarg: *optnode == NULL\n");
 	return 0;
     }
 
     handler = (*optnode)->next;
 
     while(handler) {
 	if(handler->optlong && !strcmp(handler->optlong, optlong)) {
 	    *optnode = handler;
 	    return handler->optarg;
 	}
 	handler = handler->next;
     }
 
     *optnode = NULL;
     return NULL;
 }