Dynamic help for newsearch, and permissions on terms/output functions

diff --git a/chanserv/newsearch/chanserv_newsearch.c b/chanserv/newsearch/chanserv_newsearch.c
index cd9b1e06d10edb59793399855f3565c2a6aff68d..34b70b38cc44812ea69e8d9440a0312e6e0d56d2 100644 (file)
--- a/chanserv/newsearch/chanserv_newsearch.c
+++ b/chanserv/newsearch/chanserv_newsearch.c
@@ -10,17 +10,17 @@ int cs_dospewdb(void *source, int cargc, char **cargv);
 UserDisplayFunc previousdefault;
 
 void _init() {
-  regdisp(reg_nicksearch, "auth", printnick_auth);
-  regdisp(reg_nicksearch, "authchans", printnick_authchans);
-  regdisp(reg_chansearch, "qusers", printchannel_qusers);
-  regdisp(reg_usersearch, "auth", printauth);
-
-  registersearchterm(reg_usersearch, "qusers", qusers_parse);
-  registersearchterm(reg_usersearch, "qlasthost", qlasthost_parse);
-  registersearchterm(reg_usersearch, "qemail", qemail_parse);
-  registersearchterm(reg_usersearch, "qsuspendreason", qsuspendreason_parse);
-  registersearchterm(reg_usersearch, "qusername", qusername_parse);
-  registersearchterm(reg_chansearch, "qchanflags", qchanflags_parse);
+  regdisp(reg_nicksearch, "auth", printnick_auth, 0, "");
+  regdisp(reg_nicksearch, "authchans", printnick_authchans, 0, "");
+  regdisp(reg_chansearch, "qusers", printchannel_qusers, 0, "");
+  regdisp(reg_usersearch, "auth", printauth, 0, "");
+
+  registersearchterm(reg_usersearch, "qusers", qusers_parse, 0, "");
+  registersearchterm(reg_usersearch, "qlasthost", qlasthost_parse, 0, "");
+  registersearchterm(reg_usersearch, "qemail", qemail_parse, 0, "");
+  registersearchterm(reg_usersearch, "qsuspendreason", qsuspendreason_parse, 0, "");
+  registersearchterm(reg_usersearch, "qusername", qusername_parse, 0, "");
+  registersearchterm(reg_chansearch, "qchanflags", qchanflags_parse, 0, "");
 
   chanservaddcommand("nicksearch", QCMD_OPER, 5, cs_donicksearch, "Wrapper for standard newserv nicksearch command.", "");
   chanservaddcommand("chansearch", QCMD_OPER, 5, cs_dochansearch, "Wrapper for standard newserv chansearch command.", "");

diff --git a/newsearch/newsearch.c b/newsearch/newsearch.c
index a0b276f6737b3ee4a9f9cf21dbcfbd411e182e82..b9b86020a327af02a6651042b63e041e0cda05c2 100644 (file)
--- a/newsearch/newsearch.c
+++ b/newsearch/newsearch.c
@@ -32,15 +32,18 @@ NickDisplayFunc defaultnickfn = printnick;
 ChanDisplayFunc defaultchanfn = printchannel;
 
 searchCmd *reg_nicksearch, *reg_chansearch, *reg_usersearch;
+void displaycommandhelp(nick *, Command *);
 
 searchCmd *registersearchcommand(char *name, int level, CommandHandler cmd, void *defaultdisplayfunc) {
   searchCmd *acmd;
   searchList *sl;
 
-  registercontrolhelpcmd(name, NO_OPER,4, cmd, "Usage: <criteria\nSearches with the given criteria");
-  
+  registercontrolhelpfunccmd(name, NO_OPER,4, cmd, &displaycommandhelp);  
   acmd=(struct searchCmd *)malloc(sizeof(struct searchCmd));
-
+  if (!acmd) {
+    Error("newsearch", ERR_ERROR, "malloc failed: registersearchcommand");
+    return NULL;
+  }
   acmd->handler = cmd;
 
   acmd->name = getsstring( name, NSMAX_COMMAND_LEN); 
@@ -49,10 +52,8 @@ searchCmd *registersearchcommand(char *name, int level, CommandHandler cmd, void
 
   addcommandtotree(searchCmdTree, name, 0, 0, (CommandHandler)acmd);
 
-  sl = globalterms;
-  while (sl) {
-    registersearchterm( acmd, sl->name->content, sl->cmd);
-    sl = sl->next;
+  for (sl=globalterms; sl; sl=sl->next) {
+    registersearchterm( acmd, sl->name->content, sl->cmd, 0, sl->help);
   }
 
   return acmd;
@@ -66,8 +67,68 @@ void deregistersearchcommand(searchCmd *scmd) {
   free(scmd);
 }
 
-void regdisp( searchCmd *cmd, const char *name, void *handler) {
-  addcommandtotree(cmd->outputtree, name, 0, 0, (CommandHandler) handler);
+void displaycommandhelp(nick *np, Command *cmd) {
+  int i,n,j,m;
+  Command *cmdlist[100], *acmdlist[100];
+  searchCmd *acmd;
+
+  n=getcommandlist(searchCmdTree,cmdlist,100);
+  for(i=0;i<n;i++) {
+    /* note: we may want to only deregister a command if we've already registered it, for now, try de-registering new commands anyway */
+    if ( ((searchCmd *)cmdlist[i]->handler)->handler != cmd->handler )
+      continue;
+    acmd = ((searchCmd *)(cmdlist[i]->handler)); 
+
+    controlreply(np, "Usage: [flags] <criteria>\n");
+    controlreply(np, "Flags:\n");
+    controlreply(np, " -l int    : Limit number of rows of results\n");
+    controlreply(np, " -d string : a valid output format for the results\n"); 
+    controlreply(np, " -s subset : ipmask subset of network to search (only for node search)\n");
+    controlreply(np, " \n");
+    controlreply(np, "Available Output Formats:\n");
+  
+    m=getcommandlist(acmd->outputtree,acmdlist,100);
+    for(j=0;j<m;j++) {
+      if ( controlpermitted( acmdlist[j]->level, np) ) {
+        char *help=(char *)acmdlist[j]->ext;
+        if ( help && help[0] != '\0')
+          controlreply(np, "%-10s: %s\n", acmdlist[j]->command->content, help);
+        else 
+          controlreply(np, "%s\n", acmdlist[j]->command->content ); 
+      }
+    }
+
+    controlreply(np, " \n");
+    controlreply(np, "Available Global Search Terms:\n" );
+    m=getcommandlist(acmd->searchtree,acmdlist,100);
+    for(j=0;j<m;j++) {
+      if ( acmdlist[j]->maxparams) {
+        char *help=(char *)acmdlist[j]->ext;
+        if ( help && help[0] != '\0')
+          controlreply(np, "%-10s: %s\n", acmdlist[j]->command->content, help );
+        else
+          controlreply(np, "%s\n", acmdlist[j]->command->content );
+      }
+    }
+
+    controlreply(np, " \n");
+    controlreply(np, "Available Search Terms for %s:\n", acmd->name->content);
+
+    m=getcommandlist(acmd->searchtree,acmdlist,100);
+    for(j=0;j<m;j++) {
+      if ( !acmdlist[j]->maxparams && controlpermitted( acmdlist[j]->level, np) ) {
+        char *help=(char *)acmdlist[j]->ext;
+        if ( help && help[0] != '\0')
+          controlreply(np, "%-10s: %s\n", acmdlist[j]->command->content, help );
+        else
+          controlreply(np, "%s\n", acmdlist[j]->command->content );
+      }
+    }
+  }
+}
+
+void regdisp( searchCmd *cmd, const char *name, void *handler, int level, char *help) {
+  addcommandexttotree(cmd->outputtree, name, level, 0, (CommandHandler) handler, (char *)help);
 } 
 
 void unregdisp( searchCmd *cmd, const char *name, void *handler ) {
@@ -75,11 +136,11 @@ void unregdisp( searchCmd *cmd, const char *name, void *handler ) {
 }
 
 void *findcommandinlist( searchList *sl, char *name){
-  while(sl) {
+  while (sl) {
     if(strcmp(sl->name->content,name) == 0 ) {
       return sl;
     }
-    sl = sl->next;
+    sl=sl->next;
   }
   return NULL;
 } 
@@ -97,81 +158,81 @@ void _init() {
   reg_usersearch = (searchCmd *)registersearchcommand("usersearch",NO_OPER,&do_usersearch, printuser);
 
   /* Boolean operations */
-  registerglobalsearchterm("and",and_parse);
-  registerglobalsearchterm("not",not_parse);
-  registerglobalsearchterm("or",or_parse);
+  registerglobalsearchterm("and",and_parse, "usage: (and (X) (X))" );
+  registerglobalsearchterm("not",not_parse, "usage: (not (X))");
+  registerglobalsearchterm("or",or_parse, "usage: (or (X) (X))" );
 
-  registerglobalsearchterm("eq",eq_parse);
+  registerglobalsearchterm("eq",eq_parse, "usage: (eq (X) Y)");
 
-  registerglobalsearchterm("lt",lt_parse);
-  registerglobalsearchterm("gt",gt_parse);
+  registerglobalsearchterm("lt",lt_parse, "usage: (lt (X) int)");
+  registerglobalsearchterm("gt",gt_parse, "usage: (gt (X) int)");
  
   /* String operations */
-  registerglobalsearchterm("match",match_parse);
-  registerglobalsearchterm("regex",regex_parse);
-  registerglobalsearchterm("length",length_parse);
+  registerglobalsearchterm("match",match_parse, "usage: (match (X) string)");
+  registerglobalsearchterm("regex",regex_parse, "usage: (regex (X) string)");
+  registerglobalsearchterm("length",length_parse, "usage: (length string)");
   
   /* Nickname operations */
-  registersearchterm(reg_nicksearch, "hostmask",hostmask_parse);     /* nick only */
-  registersearchterm(reg_nicksearch, "realname",realname_parse);     /* nick only */
-  registersearchterm(reg_nicksearch, "authname",authname_parse);     /* nick only */
-  registersearchterm(reg_nicksearch, "authts",authts_parse);         /* nick only */
-  registersearchterm(reg_nicksearch, "ident",ident_parse);           /* nick only */
-  registersearchterm(reg_nicksearch, "host",host_parse);             /* nick only */
-  registersearchterm(reg_nicksearch, "channel",channel_parse);       /* nick only */
-  registersearchterm(reg_nicksearch, "timestamp",timestamp_parse);   /* nick only */
-  registersearchterm(reg_nicksearch, "country",country_parse);       /* nick only */
-  registersearchterm(reg_nicksearch, "ip",ip_parse);                 /* nick only */
-  registersearchterm(reg_nicksearch, "channels",channels_parse);     /* nick only */
-  registersearchterm(reg_nicksearch, "server",server_parse);         /* nick only */
-  registersearchterm(reg_nicksearch, "authid",authid_parse);         /* nick only */
+  registersearchterm(reg_nicksearch, "hostmask",hostmask_parse, 0, "Users host mask, allow \"hostmask real\" to match realhost");     /* nick only */
+  registersearchterm(reg_nicksearch, "realname",realname_parse, 0, "");     /* nick only */
+  registersearchterm(reg_nicksearch, "authname",authname_parse, 0, "");     /* nick only */
+  registersearchterm(reg_nicksearch, "authts",authts_parse, 0, "");         /* nick only */
+  registersearchterm(reg_nicksearch, "ident",ident_parse, 0, "");           /* nick only */
+  registersearchterm(reg_nicksearch, "host",host_parse, 0, "");             /* nick only */
+  registersearchterm(reg_nicksearch, "channel",channel_parse, 0, "");       /* nick only */
+  registersearchterm(reg_nicksearch, "timestamp",timestamp_parse, 0, "");   /* nick only */
+  registersearchterm(reg_nicksearch, "country",country_parse, 0, "2 letter country code (data source is geoip)");       /* nick only */
+  registersearchterm(reg_nicksearch, "ip",ip_parse, 0, "");                 /* nick only */
+  registersearchterm(reg_nicksearch, "channels",channels_parse, 0, "");     /* nick only */
+  registersearchterm(reg_nicksearch, "server",server_parse, 0, "");         /* nick only */
+  registersearchterm(reg_nicksearch, "authid",authid_parse, 0, "");         /* nick only */
 
   /* Channel operations */
-  registersearchterm(reg_chansearch, "exists",exists_parse);         /* channel only */
-  registersearchterm(reg_chansearch, "services",services_parse);     /* channel only */
-  registersearchterm(reg_chansearch, "size",size_parse);             /* channel only */
-  registersearchterm(reg_chansearch, "name",name_parse);             /* channel only */
-  registersearchterm(reg_chansearch, "topic",topic_parse);           /* channel only */
-  registersearchterm(reg_chansearch, "oppct",oppct_parse);           /* channel only */
-  registersearchterm(reg_chansearch, "uniquehostpct",hostpct_parse); /* channel only */
-  registersearchterm(reg_chansearch, "authedpct",authedpct_parse);   /* channel only */
-  registersearchterm(reg_chansearch, "kick",kick_parse);             /* channel only */
+  registersearchterm(reg_chansearch, "exists",exists_parse, 0, "");         /* channel only */
+  registersearchterm(reg_chansearch, "services",services_parse, 0, "");     /* channel only */
+  registersearchterm(reg_chansearch, "size",size_parse, 0, "");             /* channel only */
+  registersearchterm(reg_chansearch, "name",name_parse, 0, "");             /* channel only */
+  registersearchterm(reg_chansearch, "topic",topic_parse, 0, "");           /* channel only */
+  registersearchterm(reg_chansearch, "oppct",oppct_parse, 0, "");           /* channel only */
+  registersearchterm(reg_chansearch, "uniquehostpct",hostpct_parse, 0, ""); /* channel only */
+  registersearchterm(reg_chansearch, "authedpct",authedpct_parse, 0, "");   /* channel only */
+  registersearchterm(reg_chansearch, "kick",kick_parse, 0, "");             /* channel only */
 
   /* Nickname / channel operations */
-  registersearchterm(reg_chansearch, "modes",modes_parse);
-  registersearchterm(reg_nicksearch, "modes",modes_parse);
-  registersearchterm(reg_chansearch, "nick",nick_parse);
-  registersearchterm(reg_nicksearch, "nick",nick_parse);
+  registersearchterm(reg_chansearch, "modes",modes_parse, 0, "");
+  registersearchterm(reg_nicksearch, "modes",modes_parse, 0, "");
+  registersearchterm(reg_chansearch, "nick",nick_parse, 0, "");
+  registersearchterm(reg_nicksearch, "nick",nick_parse, 0, "");
 
   /* Kill / gline parameters */
-  registersearchterm(reg_chansearch,"kill",kill_parse);
-  registersearchterm(reg_chansearch,"gline",gline_parse);
-  registersearchterm(reg_nicksearch,"kill",kill_parse);
-  registersearchterm(reg_nicksearch,"gline",gline_parse);
+  registersearchterm(reg_chansearch,"kill",kill_parse, 0, "");
+  registersearchterm(reg_chansearch,"gline",gline_parse, 0, "");
+  registersearchterm(reg_nicksearch,"kill",kill_parse, 0, "");
+  registersearchterm(reg_nicksearch,"gline",gline_parse, 0, "");
 
   /* Iteration functionality */
-  registerglobalsearchterm("any",any_parse);
-  registerglobalsearchterm("all",all_parse);
-  registerglobalsearchterm("var",var_parse);
+  registerglobalsearchterm("any",any_parse, "");
+  registerglobalsearchterm("all",all_parse, "");
+  registerglobalsearchterm("var",var_parse, "");
   
   /* Iterable functions */
-  registersearchterm(reg_nicksearch, "channeliter",channeliter_parse);         /* nick only */
+  registersearchterm(reg_nicksearch, "channeliter",channeliter_parse, 0, "");         /* nick only */
   
   /* Notice functionality */
-  registersearchterm(reg_chansearch,"notice",notice_parse);
-  registersearchterm(reg_nicksearch,"notice",notice_parse);
+  registersearchterm(reg_chansearch,"notice",notice_parse, 0, "");
+  registersearchterm(reg_nicksearch,"notice",notice_parse, 0, "");
  
   /* Nick output filters */
-  regdisp(reg_nicksearch,"default",printnick);
-  regdisp(reg_nicksearch,"channels",printnick_channels);
+  regdisp(reg_nicksearch,"default",printnick, 0, "");
+  regdisp(reg_nicksearch,"channels",printnick_channels, 0, "include channels in output");
     
   /* Channel output filters */
-  regdisp(reg_chansearch,"default",printchannel);
-  regdisp(reg_chansearch,"topic",printchannel_topic);
-  regdisp(reg_chansearch,"services",printchannel_services);
+  regdisp(reg_chansearch,"default",printchannel, 0, "");
+  regdisp(reg_chansearch,"topic",printchannel_topic, 0, "display channel topics");
+  regdisp(reg_chansearch,"services",printchannel_services, 0, "display services on channels");
 
   /* Nick output filters */
-  regdisp(reg_usersearch,"default",printuser);
+  regdisp(reg_usersearch,"default",printuser, 0, "");
  
 }
 
@@ -180,10 +241,10 @@ void _fini() {
   int i,n;
   Command *cmdlist[100];
 
-  sl = globalterms; 
+  sl=globalterms;
   while (sl) {
     psl = sl;
-    sl = sl->next;
+    sl=sl->next;
 
     n=getcommandlist(searchCmdTree,cmdlist,100);
     for(i=0;i<n;i++) {
@@ -191,8 +252,9 @@ void _fini() {
     }
 
     freesstring(psl->name);
+    if (psl->help) 
+      free (psl->help);
     free(psl);
- 
   }
 
   deregistersearchcommand( reg_nicksearch );
@@ -201,14 +263,31 @@ void _fini() {
   destroycommandtree( searchCmdTree );
 }
 
-void registerglobalsearchterm(char *term, parseFunc parsefunc) {
-  searchList *sl = malloc(sizeof(searchList));
+void registerglobalsearchterm(char *term, parseFunc parsefunc, char *help) {
   int i,n;
   Command *cmdlist[100];
+  searchList *sl = malloc(sizeof(searchList));
+  if (!sl) {
+    Error("newsearch", ERR_ERROR, "malloc failed: registerglobalsearchterm");
+    return;
+  }
 
   sl->cmd = parsefunc;
   sl->name = getsstring(term, NSMAX_COMMAND_LEN);
   sl->next = NULL;
+  if (help) {
+    int len=strlen(help);
+    sl->help=(char *)malloc(len+1);
+    if(!sl->help) {
+      Error("newsearch", ERR_ERROR, "malloc failed: registerglobalsearchterm");
+      return;
+    }
+      strncpy(sl->help, help, len);
+      sl->help[len] = '\0';
+  } else {
+    sl->help=NULL;
+  }
+
 
   if ( globalterms != NULL ) {
     sl->next = globalterms;
@@ -217,7 +296,9 @@ void registerglobalsearchterm(char *term, parseFunc parsefunc) {
 
   n=getcommandlist(searchCmdTree,cmdlist,100);
   for(i=0;i<n;i++) {
-    registersearchterm( (searchCmd *)cmdlist[i]->handler,term, parsefunc); 
+    /* maxparams is set to 1 to indicate a global term */
+    /* access level is set to 0 for all global terms */
+    addcommandexttotree( ((searchCmd *)cmdlist[i]->handler)->searchtree,term, 0, 1, (CommandHandler) parsefunc, help);
   }
 }
 
@@ -226,13 +307,11 @@ void deregisterglobalsearchterm(char *term, parseFunc parsefunc) {
   Command *cmdlist[100];
   searchList *sl, *psl=NULL;
 
-  sl = globalterms;
-  while (sl) {
+  for (sl=globalterms; sl; sl=sl->next) {
     if ( strcmp( sl->name->content, term) == 0 ) {
       break;
     }
     psl = sl;
-    sl = sl->next;
   }
 
   if (sl) {
@@ -242,18 +321,20 @@ void deregisterglobalsearchterm(char *term, parseFunc parsefunc) {
 
     n=getcommandlist(searchCmdTree,cmdlist,100);
     for(i=0;i<n;i++) {
-      deregistersearchterm( (searchCmd *)cmdlist[i]->handler, term, parsefunc);
+      deletecommandfromtree( ((searchCmd *)cmdlist[i]->handler)->searchtree, term, (CommandHandler) parsefunc);
     }
     freesstring(sl->name);
     free(sl);
   }
 }
 
-void registersearchterm(searchCmd *cmd, char *term, parseFunc parsefunc) {
-  addcommandtotree(cmd->searchtree, term, 0, 0, (CommandHandler) parsefunc);
+void registersearchterm(searchCmd *cmd, char *term, parseFunc parsefunc, int level, char *help) {
+  /* NOTE: global terms are added to the tree elsewhere as we set maxparams to 1 to indicate global */
+  addcommandexttotree(cmd->searchtree, term, level, 0, (CommandHandler) parsefunc, help);
 }
 
 void deregistersearchterm(searchCmd *cmd, char *term, parseFunc parsefunc) {
+  /* NOTE: global terms are removed from the tree within deregisterglobalsearchterm */
   deletecommandfromtree(cmd->searchtree, term, (CommandHandler) parsefunc);
 }
 
@@ -280,21 +361,25 @@ int parseopts(int cargc, char **cargv, int *arg, int *limit, void **subset, void
       switch(*ch) {
       case 'l':
        if (cargc<*arg) {
-         reply(sender,"Error: -l switch requires an argument");
-         return CMD_USAGE;
+         reply(sender,"Error: -l switch requires an argument (for help, see help <searchcmd>)");
+         return CMD_ERROR;
        }
        *limit=strtoul(cargv[(*arg)++],NULL,10);
        break;
        
       case 'd':
         if (cargc<*arg) {
-          reply(sender,"Error: -d switch requires an argument");
-          return CMD_USAGE;
+          reply(sender,"Error: -d switch requires an argument (for help, see help <searchcmd>)");
+          return CMD_ERROR;
         }
         cmd=findcommandintree(sl, cargv[*arg],1);
         if (!cmd) {
-          reply(sender,"Error: unknown output format %s",cargv[*arg]);
-          return CMD_USAGE;
+          reply(sender,"Error: unknown output format %s (for help, see help <searchcmd>)",cargv[*arg]);
+          return CMD_ERROR;
+        }
+        if ( !controlpermitted( cmd->level, sender) ) {
+          reply(sender,"Error: Access Denied for output format %s (for help, see help <searchcmd>)", cargv[*arg]);
+          return CMD_ERROR;
         }
         *display=(void *)cmd->handler;
         (*arg)++;
@@ -302,19 +387,20 @@ int parseopts(int cargc, char **cargv, int *arg, int *limit, void **subset, void
 
       case 's':
         if (cargc<*arg) {
-          reply(sender,"Error: -s switch requires an argument");
-          return CMD_USAGE;
+          reply(sender,"Error: -s switch requires an argument (for help, see help <searchcmd>)");
+          return CMD_ERROR;
         }
         if (ipmask_parse(cargv[*arg], &sin, &bits) == 0) {
-          reply(sender, "Error: Invalid CIDR mask supplied");
-          return CMD_USAGE;
+          reply(sender, "Error: Invalid CIDR mask supplied (for help, see help <searchcmd>)");
+          return CMD_ERROR;
         }
         *subset = (void *)refnode(iptree, &sin, bits);
         (*arg)++;
         break;
         
       default:
-       reply(sender,"Unrecognised flag -%c.",*ch);
+       reply(sender,"Unrecognised flag -%c. (for help, see help <searchcmd>)",*ch);
+        return CMD_ERROR;
       }
     }
   }
@@ -322,7 +408,7 @@ int parseopts(int cargc, char **cargv, int *arg, int *limit, void **subset, void
   return CMD_OK;
 }
 
-void newsearch_ctxinit(searchCtx *ctx, searchParseFunc searchfn, replyFunc replyfn, wallFunc wallfn, void *arg, searchCmd *cmd) {
+void newsearch_ctxinit(searchCtx *ctx, searchParseFunc searchfn, replyFunc replyfn, wallFunc wallfn, void *arg, searchCmd *cmd, nick *np) {
   memset(ctx, 0, sizeof(searchCtx));
   
   ctx->reply = replyfn;
@@ -330,6 +416,7 @@ void newsearch_ctxinit(searchCtx *ctx, searchParseFunc searchfn, replyFunc reply
   ctx->parser = searchfn;
   ctx->arg = arg;
   ctx->searchcmd = cmd;
+  ctx->sender = np;
 }
 
 int do_nicksearch_real(replyFunc reply, wallFunc wall, void *source, int cargc, char **cargv) {
@@ -341,9 +428,12 @@ int do_nicksearch_real(replyFunc reply, wallFunc wall, void *source, int cargc,
   searchCtx ctx;
   int ret;
 
-  if (cargc<1)
-    return CMD_USAGE;
-  
+  if (cargc<1) {
+    reply( sender, "Usage: [flags] <criteria>");
+    reply( sender, "For help, see help nicksearch");
+    return CMD_OK;
+  }
+ 
   ret = parseopts(cargc, cargv, &arg, &limit, NULL, (void **)&display, reg_nicksearch->outputtree, reply, sender);
   if(ret != CMD_OK)
     return ret;
@@ -357,7 +447,7 @@ int do_nicksearch_real(replyFunc reply, wallFunc wall, void *source, int cargc,
     rejoinline(cargv[arg],cargc-arg);
   }
 
-  newsearch_ctxinit(&ctx, search_parse, reply, wall, NULL, reg_nicksearch);
+  newsearch_ctxinit(&ctx, search_parse, reply, wall, NULL, reg_nicksearch, sender);
 
   if (!(search = ctx.parser(&ctx, cargv[arg]))) {
     reply(sender,"Parse error: %s",parseError);
@@ -428,8 +518,11 @@ int do_chansearch_real(replyFunc reply, wallFunc wall, void *source, int cargc,
   searchCtx ctx;
   int ret;
 
-  if (cargc<1)
-    return CMD_USAGE;
+  if (cargc<1) {
+    reply( sender, "Usage: [flags] <criteria>");
+    reply( sender, "For help, see help chansearch");
+    return CMD_OK;
+  }
   
   ret = parseopts(cargc, cargv, &arg, &limit, NULL, (void **)&display, reg_chansearch->outputtree, reply, sender);
   if(ret != CMD_OK)
@@ -444,7 +537,7 @@ int do_chansearch_real(replyFunc reply, wallFunc wall, void *source, int cargc,
     rejoinline(cargv[arg],cargc-arg);
   }
 
-  newsearch_ctxinit(&ctx, search_parse, reply, wall, NULL, reg_chansearch);
+  newsearch_ctxinit(&ctx, search_parse, reply, wall, NULL, reg_chansearch, sender);
   if (!(search = ctx.parser(&ctx, cargv[arg]))) {
     reply(sender,"Parse error: %s",parseError);
     return CMD_ERROR;
@@ -493,9 +586,12 @@ int do_usersearch_real(replyFunc reply, wallFunc wall, void *source, int cargc,
   searchCtx ctx;
   int ret;
 
-  if (cargc<1)
-    return CMD_USAGE;
-  
+  if (cargc<1) {
+    reply( sender, "Usage: [flags] <criteria>");
+    reply( sender, "For help, see help usersearch");
+    return CMD_OK;
+  }
+ 
   ret = parseopts(cargc, cargv, &arg, &limit, NULL, (void **)&display, reg_usersearch->outputtree, reply, sender);
   if(ret != CMD_OK)
     return ret;
@@ -509,7 +605,8 @@ int do_usersearch_real(replyFunc reply, wallFunc wall, void *source, int cargc,
     rejoinline(cargv[arg],cargc-arg);
   }
 
-  newsearch_ctxinit(&ctx, search_parse, reply, wall, NULL, reg_usersearch);
+  newsearch_ctxinit(&ctx, search_parse, reply, wall, NULL, reg_usersearch, sender);
+
   if (!(search = ctx.parser(&ctx, cargv[arg]))) {
     reply(sender,"Parse error: %s",parseError);
     return CMD_ERROR;
@@ -858,9 +955,13 @@ struct searchNode *search_parse(searchCtx *ctx, char *input) {
       j--; /* remove an argument */
     
     if (!(cmd=findcommandintree(ctx->searchcmd->searchtree,argvector[0],1))) {
-      parseError = "Unknown command";
+      parseError = "Unknown command (for valid command list, see help <searchcmd>)";
       return NULL;
     } else {
+      if ( !controlpermitted( cmd->level, ctx->sender) ) { 
+        parseError = "Access Denied (for valid command list, see help <searchcmd>)";
+        return NULL;
+      }
       return ((parseFunc)cmd->handler)(ctx, j, argvector+1);
     }
   } else {

diff --git a/newsearch/newsearch.h b/newsearch/newsearch.h
index 99fb0fb034cb8eaa25dcd268ace419b2e1ec327f..d342e319be2791ce9aa4ab56ff4388f824450158 100644 (file)
--- a/newsearch/newsearch.h
+++ b/newsearch/newsearch.h
@@ -74,6 +74,7 @@ typedef struct searchCmd {
 typedef struct searchList { 
   void *cmd;
   sstring *name;  
+  char *help;
   struct searchList *next;
 } searchList;
 
@@ -85,6 +86,7 @@ typedef struct searchCtx {
   struct searchVariable vars[MAX_VARIABLES];
   int lastvar;
   struct searchCmd *searchcmd;
+  nick *sender;
 } searchCtx;
 
 /* Core functions */
@@ -159,11 +161,13 @@ struct searchNode *coerceNode(searchCtx *ctx, struct searchNode *thenode, int ty
 /* Registration functions */
 searchCmd *registersearchcommand(char *name, int level, CommandHandler cmd, void *defaultdisplayfunc);
 void deregistersearchcommand(searchCmd *scmd);
-void registersearchterm(searchCmd *cmd, char *term, parseFunc parsefunc);
+void registersearchterm(searchCmd *cmd, char *term, parseFunc parsefunc, int level, char *help);
 void deregistersearchterm(searchCmd *cmd, char *term, parseFunc parsefunc);
-void registerglobalsearchterm(char *term, parseFunc parsefunc);
+
+void registerglobalsearchterm(char *term, parseFunc parsefunc, char *help);
 void deregisterglobalsearchterm(char *term, parseFunc parsefunc);
-void regdisp( searchCmd *cmd, const char *name, void *handler);
+
+void regdisp( searchCmd *cmd, const char *name, void *handler, int level, char *help);
 void unregdisp( searchCmd *cmd, const char *name, void *handler);
 
 /* Special nick* printf */
@@ -190,7 +194,7 @@ struct searchVariable *var_register(searchCtx *ctx, char *arg, int type);
 searchNode *var_get(searchCtx *ctx, char *arg);
 void var_setstr(struct searchVariable *v, char *data);
 
-void newsearch_ctxinit(searchCtx *ctx, searchParseFunc searchfn, replyFunc replyfn, wallFunc wallfn, void *arg, searchCmd *cmd);
+void newsearch_ctxinit(searchCtx *ctx, searchParseFunc searchfn, replyFunc replyfn, wallFunc wallfn, void *arg, searchCmd *cmd, nick *sender);
 
 /* AST functions */
 

diff --git a/newsearch/newsearch_ast.c b/newsearch/newsearch_ast.c
index 5925d447f4fa4870434a073f6eafc7c4d66b91e1..829917d38fe52d693cc7438fba01a1a0136eb3b9 100644 (file)
--- a/newsearch/newsearch_ast.c
+++ b/newsearch/newsearch_ast.c
@@ -142,7 +142,7 @@ int ast_nicksearch(searchASTExpr *tree, replyFunc reply, void *sender, wallFunc
   memset(&cache, 0, sizeof(cache));
   cache.tree = tree;
 
-  newsearch_ctxinit(&ctx, search_astparse, reply, wall, &cache, reg_nicksearch);
+  newsearch_ctxinit(&ctx, search_astparse, reply, wall, &cache, reg_nicksearch, sender);
 
   buf[0] = '\0';
   reply(sender, "Parsing: %s", ast_printtree(buf, sizeof(buf), tree, reg_nicksearch));
@@ -168,7 +168,7 @@ int ast_chansearch(searchASTExpr *tree, replyFunc reply, void *sender, wallFunc
   searchNode *search;
   char buf[1024];
 
-  newsearch_ctxinit(&ctx, search_astparse, reply, wall, &cache, reg_chansearch);
+  newsearch_ctxinit(&ctx, search_astparse, reply, wall, &cache, reg_chansearch, sender);
 
   buf[0] = '\0';
   reply(sender, "Parsing: %s", ast_printtree(buf, sizeof(buf), tree, reg_chansearch));
@@ -197,7 +197,7 @@ int ast_usersearch(searchASTExpr *tree, replyFunc reply, void *sender, wallFunc
   memset(&cache, 0, sizeof(cache));
   cache.tree = tree;
 
-  newsearch_ctxinit(&ctx, search_astparse, reply, wall, &cache, reg_usersearch);
+  newsearch_ctxinit(&ctx, search_astparse, reply, wall, &cache, reg_usersearch, sender);
 
   buf[0] = '\0';
   reply(sender, "Parsing: %s", ast_printtree(buf, sizeof(buf), tree, reg_usersearch));