Only in .: 1.sh
Only in .: CVS
diff -dur ../iroffer1.4.b02.orig/Configure ./Configure
--- ../iroffer1.4.b02.orig/Configure	Mon Jan 17 00:17:40 2005
+++ ./Configure	Tue May 10 06:26:20 2005
@@ -7,6 +7,7 @@
 
 VERSION=1.4.b02
 RELEASE=1
+MOD="1.11"
 
 if [ -d BitKeeper -a -f "`type bk 2>/dev/null | awk '{print $NF}'`" ]; then
  CSET=`bk prs -h -d':UTC:\n' -r+ ChangeSet`
@@ -18,9 +19,9 @@
 fi
 
 if [ $RELEASE -eq 1 ]; then
- VERSIONLONG="$VERSION [$CSET]"
+ VERSIONLONG="$VERSION [$CSET] mod by Dinoex $MOD"
 else
- VERSIONLONG="$VERSION [PRERELEASE $CSET]"
+ VERSIONLONG="$VERSION [PRERELEASE $CSET] mod by Dinoex $MOD"
 fi
 
 echo
Only in .: Makefile
Only in .: README.modDinoex
Only in .: TODO
Only in .: c.sh
Only in .: convertxdccfile
Only in .: d.sh
Only in .: i.sh
Only in .: iroffer
Only in .: log
Only in .: m.sh
Only in .: obj
Only in .: p.sh
Only in .: patch-dinoex-16
Only in .: r.sh
diff -dur ../iroffer1.4.b02.orig/sample.config ./sample.config
--- ../iroffer1.4.b02.orig/sample.config	Mon Jan 17 00:17:40 2005
+++ ./sample.config	Tue May 10 06:31:44 2005
@@ -40,6 +40,18 @@
 ### needed.                                                                ###
 #xdcclistfile mybot.txt
 
+##############################################################################
+###                     - xdcc listing group only  -                       ###
+### Export your xdcc list with group and main information only.            ###
+### Default ouput is all packs and no group ionformation.                  ###
+#xdcclist_grouponly
+
+#############################################################################
+###                          - admin job file -                            ###
+### when defined, read this file for commands and execute them.            ###
+### ouput will be written in <filename>.done                               ###
+#admin_job_file mybot.job
+
 
 ##############################################################################
 ##                                   IRC                                    ##
@@ -131,6 +143,12 @@
 
 
 ##############################################################################
+###                           - watch this user -                          ###
+### No new "xdcc send" are accepted, when this user is not online.         ###
+### Old queue entries are still send.                                      ###
+#enable_nick master
+
+##############################################################################
 ###                            - virtual hosts -                           ###
 ### If the computer you want to run iroffer on has multiple local IP       ###
 ### addressses, you can run iroffer on any of those ip addresses.          ###
@@ -163,6 +181,12 @@
 #usenatip 123.456.789.123
 
 ##############################################################################
+###                      - automatic dcc ip translation -                  ###
+### Get my own IP from the ircserver, and uses this as value for usenatip. ###
+### Set usenatip to a default value when using this option.                ###
+#getipfromserver
+
+##############################################################################
 ###                      - excluded from auto-ignore -                     ###
 ### These hostmasks (one per line) will never be ignored.                  ###
 #autoignore_exclude nickserv!nickserv@services.domain.com
@@ -208,6 +232,30 @@
 #filedir /home/me/files
 
 ##############################################################################
+###                 - no duplicate files -                                 ###
+### When configured, add, adddir and addnew refuses to add a files that    ###
+### already have been added. Full path is compared.                        ###
+#noduplicatefiles
+
+##############################################################################
+###                           - groups in caps -                           ###
+### if set, all groups names changed will be folded to  uppercase.         ###
+#groupsincaps
+
+##############################################################################
+###                        - auto default group -                          ###
+### When adding a new file, search for matching enries and assing the      ###
+### new file to the same group.                                            ###
+#auto_default_group
+
+##############################################################################
+###                 - adddir exlcude pattern -                             ###
+### When configured, addir and adnew will skip all files that match this   ###
+### patterns.                                                              ###
+#adddir_exclude *.txt
+#adddir_exclude *.md5
+
+##############################################################################
 ###                  - restrict xdcc list and xdcc send -                  ###
 ### if set, xdcc list and/or xdcc send|info will be restricted to users    ###
 ### who are on a known channel. If a user is not on one of the known       ###
@@ -221,6 +269,23 @@
 #restrictsend
 
 ##############################################################################
+###                      - restrictprivlistmain -                          ###
+### if set, "xdcc list" without an option will be rejected.                ###
+### this allows to list a single group only.                               ###
+#restrictprivlistmain
+
+##############################################################################
+###                      - restrictprivlistfull -                          ###
+### if set, "xdcc list all" will be rejected.                              ###
+#restrictprivlistfull
+
+##############################################################################
+##                       - need voice -                                     ##
+## Restrict list/send to only voiced/opped users.                           ##
+## restrictlist and restrictsend must be set yes.                           ##
+#need_voice
+
+##############################################################################
 ###                      - channel xdcc commands -                         ###
 ### if set, iroffer will respond to xdcc requests sent to a channel in     ###
 ### addition to xdcc requests sent to iroffer directly.                    ###
@@ -300,6 +365,11 @@
 ###           5000MB per month, and 1200MB per week, and 200MB per day.    ###
 #transferlimits 200 1200 5000
 
+##############################################################################
+###                           - start of month -                           ###
+### day of month when to reset the monthly traffic limit, default 1        ###
+#start_of_month 1
+
 
 ##############################################################################
 ##                                   Other                                  ##
@@ -318,6 +388,11 @@
 ###                             - headline -                               ###
 ### Put a headline at the top of all xdcc lists                            ###
 #headline New Stuff Just Added!!
+
+##############################################################################
+###                             - hide_list_info -                         ###
+### Don't print line with "/msg nick xdcc info #x"                         ###
+#hide_list_info
 
 ##############################################################################
 ###                           - credit line -                              ###
Only in ./src: CVS
diff -dur ../iroffer1.4.b02.orig/src/convertxdccfile.c ./src/convertxdccfile.c
--- ../iroffer1.4.b02.orig/src/convertxdccfile.c	Mon Jan 17 00:17:40 2005
+++ ./src/convertxdccfile.c	Wed Jan 19 19:17:58 2005
@@ -25,10 +25,56 @@
 
 static void usage(const char *progname)
 {
-  fprintf(stderr, "Usage: %s [-v] -x mybot.xdcc -s mybot.state\n", progname);
+  fprintf(stderr, "Usage: %s [-v] [-g] -x mybot.xdcc -s mybot.state\n", progname);
   exit(1);
 }
 
+int splizzer;
+
+struct list_s {
+  struct list_s *l_next;
+  char *l_data;
+} *seen_list;
+
+static struct list_s *seen_init(const char *data)
+{
+   struct list_s *new;
+
+   new = malloc(sizeof(struct list_s));
+   if (new == NULL)
+      return NULL;
+   new->l_next = NULL;
+   new->l_data = (data != NULL) ? strdup(data) : NULL;
+   return new;
+}
+
+static int seen(const char *data)
+{
+   struct list_s *old;
+   struct list_s *new;
+
+   if (seen_list == NULL) {
+      new = seen_init(data);
+      seen_list = new;
+      return 0;
+      }
+   old = seen_list;
+   while (old->l_next != NULL) {
+      if (old->l_data != NULL) {
+         if (strcasecmp(old->l_data,data) == 0)
+            return 1;
+         }
+      old = old->l_next;
+   }
+
+   if (old->l_data != NULL) {
+      if (strcasecmp(old->l_data,data) == 0)
+         return 1;
+      }
+   new = seen_init(data);
+   old->l_next = new;
+   return 0;
+}
 
 static void getxdccconfig(const char *filename) {
    char *templine1 = mycalloc(maxtextlength);
@@ -37,6 +83,9 @@
    char *templine4 = mycalloc(maxtextlength);
    char *templine5 = mycalloc(maxtextlength);
    char *templine6 = mycalloc(maxtextlength);
+   char *templine7 = mycalloc(maxtextlength);
+   char *templine8 = mycalloc(maxtextlength);
+   char *templine9 = mycalloc(maxtextlength);
    char *msg;
    int ok,i;
    int filedescriptor,xfiledescriptor;
@@ -136,8 +185,16 @@
       if (getfline(templine5,maxtextlength,filedescriptor,0) == NULL)  ok++;
       if (getfline(templine6,maxtextlength,filedescriptor,0) == NULL)  ok++;
       
-      if (ok)
+      if (splizzer != 0) {
+         if (getfline(templine7,maxtextlength,filedescriptor,0) == NULL)  ok++;
+         if (getfline(templine8,maxtextlength,filedescriptor,0) == NULL)  ok++;
+         if (getfline(templine9,maxtextlength,filedescriptor,0) == NULL)  ok++;
+         }
+
+      if (ok) {
+         printf("** ERROR: to read a XDCC file with group definitions use '-g'\n");
          outerror(OUTERROR_TYPE_CRASH,"XDCC file syntax error (missing/extra line)");
+         }
       
       for (i=strlen(templine1)-1; i>7 && templine1[i] == ' '; i--)
          templine1[i] = '\0';
@@ -151,6 +208,12 @@
          templine5[i] = '\0';
       for (i=strlen(templine6)-1; i>7 && templine6[i] == ' '; i--)
          templine6[i] = '\0';
+      for (i=strlen(templine7)-1; i>7 && templine7[i] == ' '; i--)
+         templine7[i] = '\0';
+      for (i=strlen(templine8)-1; i>7 && templine8[i] == ' '; i--)
+         templine8[i] = '\0';
+      for (i=strlen(templine9)-1; i>7 && templine9[i] == ' '; i--)
+         templine9[i] = '\0';
 
       if ((strlen(templine1) < 8) || strncmp(templine1+3,"file ",5)) ok++;
       if ((strlen(templine2) < 8) || strncmp(templine2+3,"desc ",5)) ok++;
@@ -158,6 +221,13 @@
       if ((strlen(templine4) < 8) || strncmp(templine4+3,"gets ",5)) ok++;
       if ((strlen(templine5) < 8) || strncmp(templine5+3,"mins ",5)) ok++;
       if ((strlen(templine6) < 8) || strncmp(templine6+3,"maxs ",5)) ok++;
+      if (splizzer != 0) {
+         if ((strlen(templine7) < 8) || strncmp(templine7+3,"data ",5)) ok++;
+         if ((strlen(templine8) < 8) || strncmp(templine8+3,"trig ",5)) ok++;
+         if ((strlen(templine9) < 8) || strncmp(templine9+3,"trno ",5)) ok++;
+         }
+      if (ok)
+         printf("error=%d, near file=%s\n", ok, templine1);
 
       if (ok)
          outerror(OUTERROR_TYPE_CRASH,"XDCC file syntax error (incorrect order?)");
@@ -176,6 +246,17 @@
       
       xd->gets     = atoi(templine4+8);
       
+      xd->group = NULL;
+      xd->group_desc = NULL;
+      if (splizzer != 0) {
+         xd->group = mycalloc(strlen(templine7+8)+1);
+         strcpy(xd->group,templine7+8);
+         if (seen(templine9+8) == 0) {
+            xd->group_desc = mycalloc(strlen(templine9+8)+1);
+            strcpy(xd->group_desc,templine9+8);
+            }
+         }
+
       xd->minspeed = gdata.transferminspeed;
       if ( atof(templine5+8) > 0)
          xd->minspeed = atof(templine5+8);
@@ -239,6 +320,10 @@
    mydelete(templine4);
    mydelete(templine5);
    mydelete(templine6);
+   mydelete(templine6);
+   mydelete(templine7);
+   mydelete(templine8);
+   mydelete(templine9);
 
    }
 
@@ -254,6 +339,8 @@
   gdata.nocolor = 1;
   gdata.noscreen = 1;
   gdata.debug = 1;
+  splizzer = 0;
+  seen_list = NULL;
   
 #if defined(_FILE_OFFSET_BITS) && (_FILE_OFFSET_BITS == 64)
   /* 4GB max size */
@@ -267,12 +354,16 @@
   gdata.startuptime = gdata.curtime = time(NULL);
   gdata.curtimems = ((unsigned long long)gdata.curtime) * 1000;
   
-  while ((callval_i = getopt(argc, argv, "vx:s:")) >= 0)
+  while ((callval_i = getopt(argc, argv, "vgx:s:")) >= 0)
     {
       switch (callval_i)
         {
         case 'v':
           gdata.debug++;
+          break;
+
+        case 'g':
+          splizzer++;
           break;
           
         case 'x':
diff -dur ../iroffer1.4.b02.orig/src/iroffer_admin.c ./src/iroffer_admin.c
--- ../iroffer1.4.b02.orig/src/iroffer_admin.c	Mon Jan 17 00:17:40 2005
+++ ./src/iroffer_admin.c	Thu May 19 07:36:42 2005
@@ -28,6 +28,11 @@
 u_respond(const userinput * const u, const char *format, ...);
 
 static void u_help(const userinput * const u);
+static int u_xdl_space(void);
+static void u_xdl_pack(char *tempstr, int i, int s, const xdcc *xd);
+static void u_xdl_head(const userinput * const u);
+static void u_xdl_full(const userinput * const u);
+static void u_xdl_group(const userinput * const u);
 static void u_xdl(const userinput * const u);
 static void u_xds(const userinput * const u);
 static void u_dcl(const userinput * const u);
@@ -45,6 +50,7 @@
 static void u_remove(const userinput * const u);
 static void u_removedir(const userinput * const u);
 static void u_send(const userinput * const u);
+static void u_queue(const userinput * const u);
 static void u_psend(const userinput * const u);
 static void u_msg(const userinput * const u);
 static void u_mesg(const userinput * const u);
@@ -57,9 +63,15 @@
 static void u_chmins(const userinput * const u);
 static void u_chmaxs(const userinput * const u);
 static void u_chgets(const userinput * const u);
+static void u_lock(const userinput * const u);
+static void u_unlock(const userinput * const u);
+static void u_groupdesc(const userinput * const u);
+static void u_group(const userinput * const u);
+static void u_regroup(const userinput * const u);
 static void u_add(const userinput * const u);
 static void u_adddir(const userinput * const u);
 static void u_addnew(const userinput * const u);
+static void u_addgroup(const userinput * const u);
 static void u_chatme(const userinput * const u);
 static void u_chatl(const userinput * const u);
 static void u_closec(const userinput * const u);
@@ -103,6 +115,8 @@
 /* local info */
 static const userinput_parse_t userinput_parse[] = {
 {1,method_allow_all,u_help,     "HELP",NULL,"Shows Help"},
+{1,method_allow_all_xdl,u_xdl_full,   "XDLFULL",NULL,"Lists All Offered Files"},
+{1,method_allow_all_xdl,u_xdl_group,  "XDLGROUP","<group>","Show <group>"},
 {1,method_allow_all_xdl,u_xdl,  "XDL",NULL,"Lists Offered Files"},
 {1,method_allow_all,u_xds,      "XDS",NULL,"Save XDCC File"},
 {1,method_allow_all,u_dcl,      "DCL",NULL,"Lists Current Transfers"},
@@ -119,6 +133,7 @@
 {2,method_allow_all,u_nomin,    "NOMIN","n","Disables Minspeed For Transfer ID n"},
 {2,method_allow_all,u_nomax,    "NOMAX","n","Disables Maxspeed For Transfer ID n"},
 {2,method_allow_all,u_send,     "SEND","nick n","Sends Pack n to nick"},
+{2,method_allow_all,u_queue,    "QUEUE","nick n","Queues Pack n for nick"},
 {2,method_allow_all,u_psend,    "PSEND","<channel> <style>","Sends <style> (full|minimal|summary) XDCC LIST to <channel>"},
 {2,method_allow_all,u_qsend,    "QSEND",NULL,"Sends Out The First Queued Pack"},
 
@@ -129,12 +144,18 @@
 {3,method_allow_all,u_add,      "ADD","<filename>","Add New Pack With <filename>"},
 {3,method_allow_all,u_adddir,   "ADDDIR","<dir>","Add Every File in <dir>"},
 {3,method_allow_all,u_addnew,   "ADDNEW","<dir>","Add any new files in <dir>"},
+{3,method_allow_all,u_addgroup, "ADDGROUP","<g> <dir>","Add any new files in <dir> to group <g>"},
 {3,method_allow_all,u_chfile,   "CHFILE","n <msg>","Change File of pack n to <msg>"},
 {3,method_allow_all,u_chdesc,   "CHDESC","n <msg>","Change Description of pack n to <msg>"},
 {3,method_allow_all,u_chnote,   "CHNOTE","n <msg>","Change Note of pack n to <msg>"},
 {3,method_allow_all,u_chmins,   "CHMINS","n x","Change min speed of pack n to x KB"},
 {3,method_allow_all,u_chmaxs,   "CHMAXS","n x","Change max speed of pack n to x KB"},
 {3,method_allow_all,u_chgets,   "CHGETS","n x","Change the get count of a pack"},
+{3,method_allow_all,u_lock,     "LOCK","n x","Lock the pack n with password x"},
+{3,method_allow_all,u_unlock,   "UNLOCK","n","Unlock the pack n"},
+{3,method_allow_all,u_groupdesc,  "GROUPDESC","<g> <msg>","Change Desc of group <g> to <msg>"},
+{3,method_allow_all,u_group,      "GROUP","n <msg>","Change Group of pack n to <msg>"},
+{3,method_allow_all,u_regroup,    "REGROUP","<g> <msg>","Change all packs of group <g> to <msg>"},
 
 {4,method_allow_all,u_msg,      "MSG","<nick> <message>","Send a message to a user"},
 {4,method_allow_all,u_mesg,     "MESG","<message>","Sends msg to all users who are transferring"},
@@ -479,17 +500,63 @@
   
 }
 
-static void u_xdl(const userinput * const u) {
+static int u_xdl_space(void) {
+   int i,s;
+   xdcc *xd;
+
+   i = 0;
+   xd = irlist_get_head(&gdata.xdccs);
+   while(xd)
+     {
+       i = max2(i,xd->gets);
+       xd = irlist_get_next(xd);
+     }
+   s = 5;
+   if (i < 10000) s = 4;
+   if (i < 1000) s = 3;
+   if (i < 100) s = 2;
+   if (i < 10) s = 1;
+   return s;
+}
+   
+static void u_xdl_pack(char *tempstr, int i, int s, const xdcc *xd) {
+   char *sizestrstr;
+   int len;
+        
+   sizestrstr = sizestr(1, xd->st_size);
+   snprintf(tempstr, maxtextlength - 1,
+           "\2#%-2i\2 %*ix [%s] %s",
+            i,
+            s, xd->gets,
+            sizestrstr,
+            xd->desc);
+   len = strlen(tempstr);
+   mydelete(sizestrstr);
+       
+   if (xd->minspeed > 0 && xd->minspeed != gdata.transferminspeed)
+     {
+        snprintf(tempstr + len, maxtextlength - 1 - len,
+                 " [%1.1fK Min]",
+                 xd->minspeed);
+        len = strlen(tempstr);
+     }
+        
+   if (xd->maxspeed > 0 && xd->maxspeed != gdata.transfermaxspeed)
+     {
+        snprintf(tempstr + len, maxtextlength - 1 - len,
+                 " [%1.1fK Max]",
+                 xd->maxspeed);
+        len = strlen(tempstr);
+     }
+}
+
+static void u_xdl_head(const userinput * const u) {
    char *tempstr;
-   const char *spaces[] = { ""," ","  ","   ","    ","     ","      " };
-   int a,i,m,m1,s;
-   float toffered;
+   int a,i,m,m1;
    int len;
    xdcc *xd;
    ir_uint64 xdccsent;
    
-   updatecontext();
-   
    tempstr  = mycalloc(maxtextlength);
 
    if (u->method==method_xdl_channel_min) m = 1; else m = 0;
@@ -587,8 +654,23 @@
        u_respond(u,"\2**\2 To request a file, type \"/msg %s xdcc send #x\" \2**\2",
                  (gdata.user_nick ? gdata.user_nick : "??"));
        
-       u_respond(u,"\2**\2 To request details, type \"/msg %s xdcc info #x\" \2**\2",
-                 (gdata.user_nick ? gdata.user_nick : "??"));
+       if (gdata.hide_list_info == 0)
+          u_respond(u,"\2**\2 To request details, type \"/msg %s xdcc info #x\" \2**\2",
+                    (gdata.user_nick ? gdata.user_nick : "??"));
+       
+       i = 0;
+       xd = irlist_get_head(&gdata.xdccs);
+       while(xd)
+         {
+           if (xd->group != NULL)
+             {
+               i++;
+             }
+           xd = irlist_get_next(xd);
+         }
+       if (i > 0)
+          u_respond(u,"\2**\2 To list a group, type \"/msg %s xdcc list GROUP\" \2**\2",
+                    (gdata.user_nick ? gdata.user_nick : "??"));
      }
    
    if (m1)
@@ -602,69 +684,143 @@
          {
            u_respond(u,"\2**\2 %s \2**\2",gdata.creditline);
          }
-       
-       mydelete(tempstr);
-       return;
      }
    
-   s = 0;
+   mydelete(tempstr);
+}
+
+static void u_xdl_full(const userinput * const u) {
+   char *tempstr;
+   xdcc *xd;
+   int i,s;
+   
+   updatecontext();
+   
+   u_xdl_head(u);
+   
+   tempstr = mycalloc(maxtextlength);
+   i = 1;
+   s = u_xdl_space();
    xd = irlist_get_head(&gdata.xdccs);
    while(xd)
      {
-       s = max2(s,xd->gets);
+       u_xdl_pack(tempstr,i,s,xd);
+       u_respond(u,"%s",tempstr);
+       i++;
        xd = irlist_get_next(xd);
      }
-   i = s; s = 5;
-   if (i < 10000) s = 4;
-   if (i < 1000) s = 3;
-   if (i < 100) s = 2;
-   if (i < 10) s = 1;
+         
+   mydelete(tempstr);
+}
+
+static void u_xdl_group(const userinput * const u) {
+   char *tempstr;
+   char *msg3;
+   xdcc *xd;
+   int i,k,s;
+
+   updatecontext();
+
+   msg3 = u->arg1;
+   if (msg3 == NULL)
+     return;
+
+   tempstr = mycalloc(maxtextlength);
+   i = 1;
+   k = 0;
+   s = u_xdl_space();
+   xd = irlist_get_head(&gdata.xdccs);
+   while(xd)
+     {
+       if (xd->group != NULL)
+         {
+           if (strcasecmp(xd->group,msg3) == 0 )
+             {
+               if (xd->group_desc != NULL)
+                 {
+                   u_respond(u,"group: %s %s",msg3,xd->group_desc);
+                 }
+
+               u_xdl_pack(tempstr,i,s,xd);
+               u_respond(u,"%s",tempstr);
+               k++;
+             }
+         }
+       i++;
+       xd = irlist_get_next(xd);
+     }
+         
+   mydelete(tempstr);
+   if (!k)
+     {
+       u_respond(u,"Sorry, nothing was found, try a XDCC LIST");
+     }
+}
+
+static void u_xdl(const userinput * const u) {
+   char *tempstr;
+   char *inlist;
+   static const char *spaces[] = { ""," ","  ","   ","    ","     ","      " };
+   int i,m,s;
+   float toffered;
+   xdcc *xd;
+   irlist_t grplist = {};
+
+   updatecontext();
    
+   u_xdl_head(u);
+
+   if (u->method==method_xdl_channel_sum) return;
+   if (u->method==method_xdl_channel_min) m = 1; else m = 0;
+
+   tempstr  = mycalloc(maxtextlength);
+   
+   s = u_xdl_space();
    i = 1;
    toffered = 0;
    xd = irlist_get_head(&gdata.xdccs);
    while(xd)
      {
-       char *sizestrstr;
        toffered += (float)xd->st_size;
        
-       sizestrstr = sizestr(1, xd->st_size);
-       snprintf(tempstr, maxtextlength - 1,
-                "\2#%-2i\2 %*ix [%s] %s",
-                i,
-                s, xd->gets,
-                sizestrstr,
-                xd->desc);
-       len = strlen(tempstr);
-       mydelete(sizestrstr);
-       
-       if (xd->minspeed > 0 && xd->minspeed != gdata.transferminspeed)
-         {
-           snprintf(tempstr + len, maxtextlength - 1 - len,
-                    " [%1.1fK Min]",
-                    xd->minspeed);
-           len = strlen(tempstr);
-         }
-       
-       if (xd->maxspeed > 0 && xd->maxspeed != gdata.transfermaxspeed)
+       /* skip is group is set */
+       if (xd->group == NULL)
          {
-           snprintf(tempstr + len, maxtextlength - 1 - len,
-                    " [%1.1fK Max]",
-                    xd->maxspeed);
-           len = strlen(tempstr);
-         }
+           u_xdl_pack(tempstr,i,s,xd);
+           u_respond(u,"%s",tempstr);
        
-       u_respond(u,"%s",tempstr);
+           if (xd->note && strlen(xd->note))
+             {
+               u_respond(u," \2^-\2%s%s",spaces[s],xd->note);
+             }
        
-       if (xd->note && strlen(xd->note))
-         {
-           u_respond(u," \2^-\2%s%s",spaces[s],xd->note);
          }
-       
        i++;
        xd = irlist_get_next(xd);
      }
    
+   xd = irlist_get_head(&gdata.xdccs);
+   while(xd)
+     {
+       /* groupe entry and entry is visible */
+       if ((xd->group != NULL) && (xd->group_desc != NULL))
+          {
+            snprintf(tempstr,maxtextlength-1,
+                     "%s %s",xd->group,xd->group_desc);
+            inlist = irlist_add(&grplist, strlen(tempstr) + 1);
+            strcpy(inlist, tempstr);
+          }
+       xd = irlist_get_next(xd);
+     }
+
+     irlist_sort(&grplist, irlist_sort_cmpfunc_string, NULL);
+     inlist = irlist_get_head(&grplist);
+     while (inlist)
+       {
+         u_respond(u,"group: %s",inlist);
+         inlist = irlist_delete(&grplist, inlist);
+       }
+   
    if (gdata.creditline)
      {
        u_respond(u,"\2**\2 %s \2**\2",gdata.creditline);
@@ -681,7 +837,7 @@
      }
    
    mydelete(tempstr);
-   }
+}
 
 static void u_xds(const userinput * const u)
 {
@@ -1047,10 +1203,10 @@
                     i,
                     pq->nick,
                     getfilename(pq->xpack->file),
-                    (gdata.curtime-pq->queuedtime)/60/60,
-                    ((gdata.curtime-pq->queuedtime)/60)%60,
-                    rtime/60/60,
-                    (rtime/60)%60);
+                    (long)((gdata.curtime-pq->queuedtime)/60/60),
+                    (long)(((gdata.curtime-pq->queuedtime)/60)%60),
+                    (long)(rtime/60/60),
+                    (long)(rtime/60)%60);
         }
       else
         {
@@ -1058,8 +1214,8 @@
                     i,
                     pq->nick,
                     getfilename(pq->xpack->file),
-                    (gdata.curtime-pq->queuedtime)/60/60,
-                    ((gdata.curtime-pq->queuedtime)/60)%60);
+                    (long)((gdata.curtime-pq->queuedtime)/60/60),
+                    (long)(((gdata.curtime-pq->queuedtime)/60)%60));
         }
       pq = irlist_get_next(pq);
       i++;
@@ -1254,8 +1410,45 @@
   return;
 }
 
+static int reorder_groupdesc(char *group, char *desc) {
+  xdcc *xd;
+  int k;
+
+  updatecontext();
+
+  k = 0;
+  xd = irlist_get_head(&gdata.xdccs);
+  while(xd)
+    {
+      if (xd->group != NULL)
+        {
+          if (strcasecmp(xd->group,group) == 0)
+            {
+              k++;
+              /* delete all matching entires */
+              if (xd->group_desc != NULL)
+                mydelete(xd->group_desc);
+              /* write only the first entry */
+              if (k == 1)
+                {
+                  if (desc && strlen(desc))
+                    {
+                      xd->group_desc = mycalloc(strlen(desc)+1);
+                      strcpy(xd->group_desc,desc);
+                    }
+                }
+            }
+        }
+      xd = irlist_get_next(xd);
+    }
+
+  return k;
+}
+
 static void u_remove(const userinput * const u) {
    int num = 0;
+   char *tmpdesc;
+   char *tmpgroup;
    pqueue *pq;
    transfer *tr;
    xdcc *xd;
@@ -1319,8 +1512,22 @@
    mydelete(xd->file);
    mydelete(xd->desc);
    mydelete(xd->note);
+   /* keep group info for later work */
+   tmpgroup = xd->group;
+   xd->group = NULL;
+   tmpdesc = xd->group_desc;
+   xd->group_desc = NULL;
    irlist_delete(&gdata.xdccs, xd);
    
+   if (tmpdesc != NULL)
+     {
+       if (tmpgroup != NULL)
+         reorder_groupdesc(tmpgroup,tmpdesc);
+       mydelete(tmpdesc);
+     }
+   if (tmpgroup != NULL)
+     mydelete(tmpgroup);
+   
    write_statefile();
    xdccsavetext();
    }
@@ -1391,7 +1598,7 @@
           mydelete(tempstr);
           continue;
         }
-      else if (!S_ISREG(st.st_mode))
+      if (!S_ISREG(st.st_mode))
         {
           mydelete(tempstr);
           continue;
@@ -1471,10 +1678,68 @@
    
    u_respond(u,"Sending %s pack %i",u->arg1,num);
    
-   sendxdccfile(u->arg1,"man","man",num,NULL);
+   sendxdccfile(u->arg1,"man","man",num,NULL,NULL);
    
    }
 
+/* this function imported from iroffer-lamm */
+static void u_queue(const userinput * const u) {
+   int num = 0;
+   int alreadytrans;
+   pqueue *pq;
+   xdcc *xd;
+   char *tempstr;
+
+   updatecontext();
+   
+   if (u->arg2) num = atoi(u->arg2);
+   
+   if (!u->arg1 || !strlen(u->arg1)) {
+      u_respond(u,"Try Specifying a Nick");
+      return;
+      }
+   
+   if (num > irlist_size(&gdata.xdccs) || num < 1) {
+      u_respond(u,"Try Specifying a Valid Pack Number");
+      return;
+      }
+
+   xd = irlist_get_nth(&gdata.xdccs, num-1);
+
+   alreadytrans = 0;
+   pq = irlist_get_head(&gdata.mainqueue);
+   while(pq)
+     {
+       if (!strcasecmp(pq->nick,u->arg1))
+         {
+           if (pq->xpack == xd)
+             {
+               alreadytrans++;
+               break;
+             }
+         }
+       pq = irlist_get_next(pq);
+     }
+
+   if (alreadytrans > 0) {
+      u_respond(u,"Already Queued %s for Pack %i!", u->arg1,num);
+      return;
+      }
+   
+   u_respond(u,"Queueing %s for Pack %i", u->arg1,num);
+   
+   tempstr = addtoqueue(u->arg1, "man", num);
+   notice(u->arg1, "** %s", tempstr);
+   mydelete(tempstr);
+   
+   if (!gdata.exiting &&
+       irlist_size(&gdata.mainqueue) &&
+       (irlist_size(&gdata.trans) < min2(MAXTRANS,gdata.slotsmax)))
+     {
+       sendaqueue(0);
+     }
+   }
+
 static void u_psend(const userinput * const u)
 {
   userinput manplist;
@@ -1731,10 +1996,76 @@
    
    }
 
+#include <ctype.h>
+
+static void strtextcpy(char *d, const char *s) {
+   const char *x;
+   char *w;
+   char ch;
+   size_t l;
+   
+   if (d == NULL)
+      return;
+   if (s == NULL)
+      return;
+   
+   /* ignore path */
+   x = strrchr(s, '/');
+   if (x != NULL)
+      x ++;
+   else
+      x = s;
+   
+   strcpy(d,x);
+   /* ignore extension */
+   w = strrchr(d, '.');
+   if (w != NULL)
+      *w = 0;
+   
+   l = strlen(d);
+   if ( l < 8 )
+      return;
+
+   w = d + l - 1;
+   ch = *w;
+   switch (ch) {
+   case '}':
+      w = strrchr(d, '{');
+      if (w != NULL)
+         *w = 0;
+      break;
+   case ')':
+      w = strrchr(d, '(');
+      if (w != NULL)
+         *w = 0;
+      break;
+   case ']':
+      w = strrchr(d, '[');
+      if (w != NULL)
+         *w = 0;
+      break;
+   }
+
+   /* strip numbers */
+   x = d;
+   w = d;
+   for (;;) {
+      ch = *(x++);
+      *w = ch;
+      if (ch == 0)
+         break;
+      if (isalpha(ch))
+         w++;
+   }
+}
+
 static void u_add(const userinput * const u) {
    int xfiledescriptor;
    struct stat st;
    xdcc *xd;
+   char *group;
+   char *a1;
+   char *a2;
    
    updatecontext();
    
@@ -1743,6 +2074,40 @@
       return;
       }
    
+   if (gdata.noduplicatefiles) {
+      xd = irlist_get_head(&gdata.xdccs);
+      while(xd)
+         {
+           if (!strcmp(u->arg1e, xd->file))
+             {
+               u_respond(u,"File '%s' is already added.", u->arg1e);
+               return;
+             }
+           xd = irlist_get_next(xd);
+         }
+      }
+
+   group = NULL;
+   if (gdata.auto_default_group) {
+      a1 = mycalloc(strlen(u->arg1e) + 1);
+      strtextcpy(a1, u->arg1e);
+      xd = irlist_get_head(&gdata.xdccs);
+      while(xd)
+         {
+           a2 = mycalloc(strlen(xd->file) + 1);
+           strtextcpy(a2, xd->file);
+           if (!strcmp(a1, a2))
+             {
+               group = xd->group;
+               mydelete(a2);
+               break;
+             }
+           mydelete(a2);
+           xd = irlist_get_next(xd);
+         }
+      mydelete(a1);
+      }
+   
    xd = irlist_add(&gdata.xdccs, sizeof(xdcc));
    
    xd->file = mycalloc(strlen(u->arg1e)+1);
@@ -1835,11 +2200,38 @@
    u_respond(u, "ADD PACK: [Pack: %i] [File: %s] Use CHDESC to change description",
              irlist_size(&gdata.xdccs),xd->file);
    
+   if ((gdata.auto_default_group) && (group != NULL)) {
+         xd->group = mycalloc(strlen(group)+1);
+         strcpy(xd->group,group);
+         u_respond(u,"GROUP: [Pack: %i] New: %s",
+                   irlist_size(&gdata.xdccs), xd->group);
+      }
+   
    write_statefile();
    xdccsavetext();
    
    }
 
+#include <fnmatch.h>
+static int verifyshell(irlist_t *list, const char *file)
+{
+  char *pattern;
+
+  updatecontext();
+
+  pattern = irlist_get_head(list);
+  while (pattern)
+    {
+    if (fnmatch(pattern,file,FNM_CASEFOLD) == 0)
+      {
+        return 1;
+      }
+    pattern = irlist_get_next(pattern);
+    }
+
+  return 0;
+}
+
 static void u_adddir(const userinput * const u)
 {
   DIR *d;
@@ -1893,6 +2285,9 @@
       struct stat st;
       int len = strlen(f->d_name);
       
+      if (verifyshell(&gdata.adddir_exclude, f->d_name))
+        continue;
+      
       tempstr = mycalloc(len + thedirlen + 2);
       
       snprintf(tempstr, len + thedirlen + 2,
@@ -1989,6 +2384,132 @@
       struct stat st;
       int len = strlen(f->d_name);
       
+      if (verifyshell(&gdata.adddir_exclude, f->d_name))
+        continue;
+      
+      tempstr = mycalloc(len + thedirlen + 2);
+      
+      snprintf(tempstr, len + thedirlen + 2,
+               "%s/%s", thedir, f->d_name);
+      
+      if (stat(tempstr,&st) < 0)
+        {
+          u_respond(u,"cannot access %s, ignoring: %s",
+                    tempstr, strerror(errno));
+        }
+      else if (S_ISREG(st.st_mode))
+        {
+          foundit = 0;
+          xd = irlist_get_head(&gdata.xdccs);
+          while(xd)
+            {
+              if (!strcmp(tempstr, xd->file))
+                {
+                  foundit = 1;
+                  break;
+                }
+              
+              xd = irlist_get_next(xd);
+            }
+          
+          if (foundit == 0)
+            {
+              thefile = irlist_add(&dirlist, len + thedirlen + 2);
+              strcpy(thefile, tempstr);
+            }
+        }
+      mydelete(tempstr);
+    }
+  
+  closedir(d);
+  
+  irlist_sort(&dirlist, irlist_sort_cmpfunc_string, NULL);
+  
+  u_respond(u,"Adding %d new files...",
+            irlist_size(&dirlist));
+  
+  thefile = irlist_get_head(&dirlist);
+  while (thefile)
+    {
+      userinput u2;
+      u_respond(u,"  Adding %s:",thefile);
+      
+      u2 = *u;
+      u2.arg1e = thefile;
+      u_add(&u2);
+      
+      thefile = irlist_delete(&dirlist, thefile);
+    }
+  
+  mydelete(thedir);
+  return;
+}
+
+static void u_addgroup(const userinput * const u)
+{
+  DIR *d;
+  struct dirent *f;
+  char *thefile, *tempstr, *thedir;
+  irlist_t dirlist = {};
+  int thedirlen, foundit;
+  xdcc *xd;
+  
+  updatecontext();
+  
+  if (!u->arg1 || !strlen(u->arg1))
+    {
+      u_respond(u,"Try Specifying a Group");
+      return;
+    }
+  
+  if (!u->arg2e || !strlen(u->arg2e))
+    {
+      u_respond(u,"Try Specifying a Directory");
+      return;
+    }
+  
+  convert_to_unix_slash(u->arg2e);
+  if (gdata.groupsincaps)
+    caps(u->arg1);
+   
+  if (u->arg2e[strlen(u->arg2e)-1] == '/')
+    {
+      u->arg2e[strlen(u->arg2e)-1] = '\0';
+    }
+  
+  thedirlen = strlen(u->arg2e);
+  if (gdata.filedir)
+    {
+      thedirlen += strlen(gdata.filedir) + 1;
+    }
+  
+  thedir = mycalloc(thedirlen+1);
+  strcpy(thedir, u->arg2e);
+  
+  d = opendir(thedir);
+  
+  if (!d && (errno == ENOENT) && gdata.filedir)
+    {
+      snprintf(thedir, thedirlen+1, "%s/%s",
+               gdata.filedir, u->arg2e);
+      d = opendir(thedir);
+    }
+  
+  if (!d)
+    {
+      u_respond(u,"Can't Access Directory: %s",strerror(errno));
+      return;
+    }
+  
+  
+  while ((f = readdir(d)))
+    {
+      struct stat st;
+      int len = strlen(f->d_name);
+      
+      if (verifyshell(&gdata.adddir_exclude, f->d_name))
+        continue;
+      
       tempstr = mycalloc(len + thedirlen + 2);
       
       snprintf(tempstr, len + thedirlen + 2,
@@ -2040,6 +2561,20 @@
       u2.arg1e = thefile;
       u_add(&u2);
       
+      xd = irlist_get_head(&gdata.xdccs);
+      while(xd)
+         {
+           if (!strcmp(thefile,xd->file))
+             {
+               if (xd->group != NULL)
+                  mydelete(xd->group);
+               xd->group = mycalloc(strlen(u->arg1)+1);
+               strcpy(xd->group,u->arg1);
+               break;
+             }
+           xd = irlist_get_next(xd);
+         }
+      
       thefile = irlist_delete(&dirlist, thefile);
     }
   
@@ -2209,6 +2744,202 @@
   
   xd->gets = atoi(u->arg2);
   
+  write_statefile();
+  xdccsavetext();
+}
+
+static void u_lock(const userinput * const u)
+{
+  int num = 0;
+  xdcc *xd;
+  
+  updatecontext();
+  
+  if (u->arg1)
+    {
+      num = atoi(u->arg1);
+    }
+  
+  if (num < 1 || num > irlist_size(&gdata.xdccs))
+    {
+      u_respond(u,"Try Specifying a Valid Pack Number");
+      return;
+    }
+  
+  if (!u->arg2 || !strlen(u->arg2))
+    {
+      u_respond(u,"Try Specifying a Password");
+      return;
+    }
+  
+  xd = irlist_get_nth(&gdata.xdccs, num-1);
+  
+  u_respond(u, "LOCK: [Pack %i] Password: %s", num, u->arg2e);
+  xd->lock = mycalloc(strlen(u->arg2e)+1);
+  strcpy(xd->lock,u->arg2e);
+
+  write_statefile();
+  xdccsavetext();
+}
+
+static void u_unlock(const userinput * const u)
+{
+  int num = 0;
+  xdcc *xd;
+  
+  updatecontext();
+  
+  if (u->arg1)
+    {
+      num = atoi(u->arg1);
+    }
+  
+  if (num < 1 || num > irlist_size(&gdata.xdccs))
+    {
+      u_respond(u,"Try Specifying a Valid Pack Number");
+      return;
+    }
+  
+  xd = irlist_get_nth(&gdata.xdccs, num-1);
+  u_respond(u, "UNLOCK: [Pack %i]", num);
+  
+  mydelete(xd->lock);
+  xd->lock = NULL;
+  
+  write_statefile();
+  xdccsavetext();
+}
+
+static void u_groupdesc(const userinput * const u) {
+  int k;
+
+  updatecontext();
+
+  if (!u->arg1 || !strlen(u->arg1))
+    {
+      u_respond(u,"Try Specifying a Valid Group");
+      return;
+    }
+   
+  k = reorder_groupdesc(u->arg1,u->arg2e);
+  if (k == 0)
+    return;
+
+  if (u->arg2e && strlen(u->arg2e))
+    {
+      u_respond(u, "New GROUPDESC: %s",u->arg2e);
+    }
+  else
+    {
+      u_respond(u, "Removed GROUPDESC");
+    }
+  write_statefile();
+  xdccsavetext();
+}
+
+static void u_group(const userinput * const u) {
+  xdcc *xd;
+  const char *new;
+  int num = 0;
+  
+  updatecontext();
+  
+  if (u->arg1)
+    {
+      num = atoi(u->arg1);
+    }
+  
+  if (num < 1 || num > irlist_size(&gdata.xdccs))
+    {
+      u_respond(u,"Try Specifying a Valid Pack Number");
+      return;
+    }
+  
+  xd = irlist_get_nth(&gdata.xdccs, num-1);
+
+  new = u->arg2;
+  if (!u->arg2 || !strlen(u->arg2))
+    {
+      if (xd->group == NULL)
+      {
+        u_respond(u,"Try Specifying a Group");
+        return;
+      }
+      new = "MAIN";
+    }
+  else
+    {
+       if (gdata.groupsincaps)
+         caps(u->arg2);
+    }
+  
+  if (xd->group != NULL)
+    {
+      u_respond(u, "GROUP: [Pack %i] Old: %s New: %s",
+                num,xd->group,new);
+      mydelete(xd->group);
+    }
+  else
+    {
+      u_respond(u, "GROUP: [Pack %i] New: %s",
+                num,u->arg2e);
+    }
+  
+  if (new == u->arg2)
+    {
+      xd->group = mycalloc(strlen(u->arg2e)+1);
+      strcpy(xd->group,u->arg2e);
+    }
+  
+  write_statefile();
+  xdccsavetext();
+}
+
+static void u_regroup(const userinput * const u) {
+  xdcc *xd;
+  const char *g;
+  int k;
+
+  updatecontext();
+
+  if (!u->arg1 || !strlen(u->arg1))
+    {
+      u_respond(u,"Try Specifying a Valid Group");
+      return;
+    }
+   
+  if (!u->arg2e || !strlen(u->arg2e))
+    {
+      u_respond(u,"Try Specifying a Valid Group");
+      return;
+    }
+   
+  if (gdata.groupsincaps)
+    caps(u->arg1);
+   
+  k = 0;
+  xd = irlist_get_head(&gdata.xdccs);
+  while(xd)
+    {
+      if (xd->group != NULL)
+        g = xd->group;
+      else
+        g = "main";
+      if (strcasecmp(g,u->arg1) == 0)
+        {
+          k++;
+          if (xd->group != NULL)
+            mydelete(xd->group);
+          xd->group = mycalloc(strlen(u->arg2e)+1);
+          strcpy(xd->group,u->arg2e);
+        }
+      xd = irlist_get_next(xd);
+    }
+
+  if (k == 0)
+    return;
+
+  u_respond(u, "GROUP: Old: %s New: %s", u->arg1, u->arg2e);
   write_statefile();
   xdccsavetext();
 }
Only in ./src: iroffer_config.h
diff -dur ../iroffer1.4.b02.orig/src/iroffer_globals.h ./src/iroffer_globals.h
--- ../iroffer1.4.b02.orig/src/iroffer_globals.h	Mon Jan 17 00:17:40 2005
+++ ./src/iroffer_globals.h	Tue May 10 06:24:44 2005
@@ -85,6 +85,19 @@
 char *restrictprivlistmsg;
 int punishslowusers;
 int nomd5sum;
+int getipfromserver;
+int noduplicatefiles;
+irlist_t adddir_exclude;
+char *enable_nick;
+int need_voice;
+int hide_list_info;
+int xdcclist_grouponly;
+int auto_default_group;
+int start_of_month;
+int restrictprivlistmain;
+int restrictprivlistfull;
+int groupsincaps;
+char *admin_job_file;
 char *nickserv_pass;
 int notifytime;
 int respondtochannelxdcc;
diff -dur ../iroffer1.4.b02.orig/src/iroffer_headers.h ./src/iroffer_headers.h
--- ../iroffer1.4.b02.orig/src/iroffer_headers.h	Mon Jan 17 00:17:40 2005
+++ ./src/iroffer_headers.h	Thu Apr  7 07:50:46 2005
@@ -142,6 +142,9 @@
 
 typedef struct {
    char *file, *desc, *note;
+   char *group;
+   char *group_desc;
+   char *lock;
    int gets;
    float minspeed,
          maxspeed;
@@ -409,7 +412,7 @@
 /*------------ function declarations ------------- */
 
 /* iroffer.c */
-void sendxdccfile(const char* nick, const char* hostname, const char* hostmask, int pack, const char* msg);
+void sendxdccfile(const char* nick, const char* hostname, const char* hostmask, int pack, const char* msg, const char* pwd);
 void sendxdccinfo(const char* nick, const char* hostname, const char* hostmask, int pack, const char* msg);
 void sendaqueue(int type);
 
@@ -611,6 +614,7 @@
 const char *transferlimit_type_to_string(transferlimit_type_e type);
 
 /* misc.c */
+void update_natip (const char *var);
 void getconfig (void);
 void getconfig_set (const char *line, int rehash);
 void initirc(void);
@@ -649,6 +653,7 @@
 void notifybandwidthtrans(void);
 void look_for_file_changes(xdcc *xpack);
 void user_changed_nick(const char *oldnick, const char *newnick);
+int has_joined_channels(int all);
 void reverify_restrictsend(void);
 
 /* statefile.c */
@@ -712,6 +717,9 @@
 void u_fillwith_clean(userinput * const u);
 
 void u_parseit(userinput * const u);
+
+/* main.c */
+char* addtoqueue(const char* nick, const char* hostname, int pack);
 
 #endif
 
diff -dur ../iroffer1.4.b02.orig/src/iroffer_main.c ./src/iroffer_main.c
--- ../iroffer1.4.b02.orig/src/iroffer_main.c	Mon Jan 17 00:17:40 2005
+++ ./src/iroffer_main.c	Thu May 12 07:43:05 2005
@@ -26,7 +26,6 @@
 static void parseline(char *line);
 static void privmsgparse(const char* type, char* line);
 static void autosendf(char* line);
-static char* addtoqueue(const char* nick, const char* hostname, int pack);
 static int  parsecmdline(int argc, char *argv[]);
 
 /* main */
@@ -198,6 +197,73 @@
   
 }
 
+static void admin_line(int fd, const char *line) {
+   userinput *uxdl;
+   
+   if (line == NULL)
+      return;
+   
+   uxdl = mycalloc(sizeof(userinput));
+   
+   u_fillwith_msg(uxdl,NULL,line);
+   uxdl->method = method_fd;
+   uxdl->fd = fd;
+   
+   u_parseit(uxdl);
+   
+   mydelete(uxdl);
+}
+
+static void admin_jobs(const char *job) {
+   FILE *fin;
+   int fd;
+   char *done;
+   char *line;
+   char *l;
+   char *r;
+   
+   if (job == NULL)
+      return;
+
+   fin = fopen(job, "ra" );
+   if (fin == NULL)
+      return;
+
+   line = mycalloc(maxtextlength);
+
+   done = mycalloc(strlen(job)+6);
+   strcpy(done,job);
+   strcat(done,".done");
+   fd = open(done,
+             O_WRONLY | O_CREAT | O_APPEND | ADDED_OPEN_FLAGS,
+             CREAT_PERMISSIONS);
+   if (fd < 0)
+    {
+      outerror(OUTERROR_TYPE_WARN_LOUD,
+               "Cant Create Admin Job Done File '%s': %s",
+               done, strerror(errno));
+    }
+  else
+    {
+      while (!feof(fin)) {
+         strcpy(line, "A A A A A ");
+         l = line + strlen(line);
+         r = fgets(l, maxtextlength - 1, fin);
+         if (r == NULL )
+            break;
+         l = line + strlen(line) - 1;
+         while (( *l == '\r' ) || ( *l == '\n' ))
+            *(l--) = 0;
+         admin_line(fd,line);
+      }
+      close(fd);
+    }
+   mydelete(line)
+   mydelete(done)
+   fclose(fin);
+   unlink(job);
+}
+
 static void mainloop (void) {
    /* data is persistant across calls */
    static char server_input_line[INPUT_BUFFER_LENGTH];
@@ -1118,7 +1184,7 @@
                       
                     case TRANSFERLIMIT_MONTHLY:
                       /* next month */
-                      localt->tm_mday = 1;
+                      localt->tm_mday = gdata.start_of_month;
                       localt->tm_mon++;
                       break;
                       
@@ -1573,7 +1639,8 @@
             
             tostdout("\x1b[%d;%dH]\x1b[u",gdata.termlines,gdata.termcols);
             }
-
+         
+         admin_jobs(gdata.admin_job_file);
          }
       
       updatecontext();
@@ -1787,6 +1854,16 @@
    if ( !strcmp(part2,"001") )
      {
        ioutput(CALLTYPE_NORMAL,OUT_S,COLOR_NO_COLOR,"Server welcome: %s",line);
+       mylog(CALLTYPE_NORMAL,"Server welcome: %s",line);
+       if (gdata.getipfromserver)
+         {
+           tptr = strchr(line, '@');
+           if (tptr != NULL)
+             {
+             ioutput(CALLTYPE_NORMAL,OUT_S,COLOR_NO_COLOR,"IP From Server: %s",tptr+1);
+	     update_natip(tptr+1);
+             }
+         }
        
        /* update server name */
        mydelete(gdata.curserveractualname);
@@ -1864,7 +1941,11 @@
 	 {
 	   for (i=0; (t2 = t = getpart(line,6+i)); i++)
 	     {
-	       while ((t[0] == ':') ||
+               int hasvoice = 0;
+
+	       while (t[0] == ':')
+                 t++;
+	       while ((t[0] == '*') ||
                       (t[0] == '@') ||
                       (t[0] == '+') ||
                       (t[0] == '!') ||
@@ -1874,15 +1955,54 @@
                       (t[0] == '&'))
                  {
                    t++;
+                   hasvoice = 1;
+                 }
+               
+               if (gdata.need_voice != 0)
+                 {
+                   if (hasvoice != 0)
+                     addtomemberlist(ch,t);
+                 }
+               else
+                 {
+                   addtomemberlist(ch,t);
                  }
-	       
-	       addtomemberlist(ch,t);
-	       
 	       mydelete(t2);
 	     }
 	 }
      }
+  
+  /* MODE channel +v nick */
+   if ((gdata.need_voice != 0) && !strncmp(part2,"MODE",4) 
+      && part3 && part4 && part5)
+     {
+       caps(part3);
+       
+       ch = irlist_get_head(&gdata.channels);
+       while(ch)
+         {
+           if (!strcmp(part3,ch->name))
+             {
+               break;
+             }
+           ch = irlist_get_next(ch);
+         }
    
+       if (ch)
+         { 
+           if (part4[0] == '+')
+            {
+		if (strpbrk(part4,"ahoqv") != NULL)
+                  addtomemberlist(ch,part5);
+            } 
+           if (part4[0] == '-')
+            { 
+		if (strpbrk(part4,"ahoqv") != NULL)
+                  removefrommemberlist(ch,part5);
+            } 
+         }
+     }
+  
  /* ERROR :Closing Link */
    if (strncmp(line, "ERROR :Closing Link", strlen("ERROR :Closing Link")) == 0) {
       if (gdata.exiting)
@@ -1940,10 +2060,25 @@
               ch = irlist_get_next(ch);
             }
           
+
           if (!ch)
             {
               ioutput(CALLTYPE_NORMAL,OUT_S|OUT_L|OUT_D,COLOR_NO_COLOR,"%s is not a known channel!",part3a);
             }
+
+          /* we have joined all channels => restart transfers if needed */
+          if (has_joined_channels(1) > 0)
+            {
+              for (i=0; i<100; i++)
+                {
+                  if (!gdata.exiting &&
+                      irlist_size(&gdata.mainqueue) &&
+                      (irlist_size(&gdata.trans) < min2(MAXTRANS,gdata.slotsmax)))
+                    {
+                      sendaqueue(0);
+                    }
+                }
+            }
         }
       else
 	{
@@ -1965,7 +2100,8 @@
             }
 	  else
             {
-              addtomemberlist(ch,nick);
+	      if (gdata.need_voice == 0)
+                addtomemberlist(ch,nick);
             }
 	}
 	
@@ -2594,7 +2730,10 @@
 	 else if (gdata.restrictlist && (!isinmemberlist(nick)))
 	   {
 	     j = 2; /* deny */
-	     notice(nick,"XDCC LIST Denied. You must be on a known channel to request a list");
+	     if (gdata.need_voice != 0)
+	        notice(nick,"XDCC LIST Denied. You must have voice or more on this channel to request a list");
+             else
+	        notice(nick,"XDCC LIST Denied. You must be on a known channel to request a list");
 	   }
 	 else
 	   {
@@ -2619,13 +2758,79 @@
                    }
                  else
                    {
-                     user = irlist_add(&gdata.xlistqueue, strlen(nick) + 1);
-                     strcpy(user,nick);
+                     if (msg3)
+                       {
+                         userinput *pubplist;
+                         char *tempstr = mycalloc(maxtextlength);
+                         
+                         j = 3; /* msg3 */
+                         /* detect xdcc list group xxx */
+                         if ((msg4) && (strcmp(caps(msg3),"GROUP") == 0))
+                           {
+                             char *msg0;
+                             msg0 = msg4;
+                             msg4 = msg3;
+                             msg3 = msg0;
+                           }
+                         if ((msg3) && (strcmp(caps(msg3),"ALL") == 0))
+                           {
+                             if (gdata.restrictprivlistfull)
+                               {
+                                 j = 2; /* deny */
+                                 if (gdata.restrictprivlistmsg)
+                                   {
+                                     notice(nick,"XDCC LIST Denied. %s", gdata.restrictprivlistmsg);
+                                   }
+                                 else
+                                   {
+                                     notice(nick,"XDCC LIST Denied. Wait for the public list in the channel.");
+                                   }
+                               }
+                             else
+                               {
+                                 snprintf(tempstr,maxtextlength-1,"A A A A A xdlfull %s",msg3);
+                               }
+                           }
+                         else
+                           {
+                             snprintf(tempstr,maxtextlength-1,"A A A A A xdlgroup %s",msg3);
+                           }
+                         if ( j == 3 )
+                           {
+                             pubplist = mycalloc(sizeof(userinput));
+                             u_fillwith_msg(pubplist,nick,tempstr);
+                             pubplist->method = method_xdl_user_notice;
+                             u_parseit(pubplist);
+                             mydelete(pubplist);
+                             mydelete(tempstr);
+                           }
+                       }
+                     else
+                       {
+                         if (gdata.restrictprivlistmain)
+                           {
+                             j = 2; /* deny */
+                             if (gdata.restrictprivlistmsg)
+                               {
+                                 notice(nick,"XDCC LIST Denied. %s", gdata.restrictprivlistmsg);
+                               }
+                             else
+                               {
+                                 notice(nick,"XDCC LIST Denied. Wait for the public list in the channel.");
+                               }
+                           }
+                         else
+                           {
+                             user = irlist_add(&gdata.xlistqueue, strlen(nick) + 1);
+                             strcpy(user,nick);
+                           }
+                       }
                    }
                }
 	   }
 	 
-         ioutput(CALLTYPE_NORMAL,OUT_S|OUT_L|OUT_D,COLOR_YELLOW,"XDCC LIST %s: (%s)",(j==1?"ignored":(j==2?"denied":"queued")),hostmask);
+         ioutput(CALLTYPE_NORMAL,OUT_S|OUT_L|OUT_D,COLOR_YELLOW,"XDCC LIST %s: (%s)",
+                 (j==1?"ignored":(j==2?"denied":(j==3?msg3:"queued"))),hostmask);
          
          }
       else if (gdata.caps_nick && !strcmp(gdata.caps_nick,dest))
@@ -2634,7 +2839,7 @@
          if ( msg2 && msg3 && (!strcmp(msg2,"SEND") || !strcmp(msg2,"GET"))) {
          if (!gdata.attop) gototop();
          ioutput(CALLTYPE_MULTI_FIRST,OUT_S|OUT_L|OUT_D,COLOR_YELLOW,"XDCC SEND %s",msg3);
-         sendxdccfile(nick, hostname, hostmask, packnumtonum(msg3), NULL);
+         sendxdccfile(nick, hostname, hostmask, packnumtonum(msg3), NULL, msg4);
          }
          else if ( msg2 && msg3 && (!strcmp(msg2,"INFO"))) {
          if (!gdata.attop) gototop();
@@ -2822,7 +3027,7 @@
        snprintf(tempstr, strlen(gdata.autosend.message) + strlen(format) - 1,
                        format, gdata.autosend.message);
        
-       sendxdccfile(nick, hostname, hostmask, gdata.autosend.pack, tempstr);
+       sendxdccfile(nick, hostname, hostmask, gdata.autosend.pack, tempstr, NULL);
        
        mydelete(tempstr);
      }
@@ -2832,7 +3037,16 @@
 
    }
 
-void sendxdccfile(const char* nick, const char* hostname, const char* hostmask, int pack, const char* msg)
+static int check_lock(const char* lockstr, const char* pwd)
+{
+  if (lockstr == NULL)
+    return 0; /* no lock */
+  if (pwd == NULL)
+    return 1; /* locked */
+  return strcmp(lockstr, pwd);
+}
+
+void sendxdccfile(const char* nick, const char* hostname, const char* hostmask, int pack, const char* msg, const char* pwd)
 {
   int usertrans, userpackok, man;
   xdcc *xd;
@@ -2861,7 +3075,16 @@
   else if (!man && gdata.restrictsend && !isinmemberlist(nick))
     {
       ioutput(CALLTYPE_MULTI_MIDDLE,OUT_S|OUT_L|OUT_D,COLOR_YELLOW," Denied (restricted): ");
-      notice(nick,"** XDCC SEND denied, you must be on a known channel to request a pack");
+      if (gdata.need_voice != 0)
+        notice(nick,"** XDCC SEND denied, you must have voice on a known channel to request a pack");
+      else
+        notice(nick,"** XDCC SEND denied, you must be on a known channel to request a pack");
+      goto done;
+    }
+  else if (!man && gdata.enable_nick && !isinmemberlist(gdata.enable_nick))
+    {
+      ioutput(CALLTYPE_MULTI_MIDDLE,OUT_S|OUT_L|OUT_D,COLOR_YELLOW," Denied (offline): ");
+      notice(nick,"** XDCC SEND denied, owner of this bot is not online");
       goto done;
     }
   else if ((pack > irlist_size(&gdata.xdccs)) || (pack < 1))
@@ -2872,6 +3095,12 @@
     }
   
   xd = irlist_get_nth(&gdata.xdccs, pack-1);
+  if (!man && (check_lock(xd->lock, pwd) != 0))
+    {
+      ioutput(CALLTYPE_MULTI_MIDDLE,OUT_S|OUT_L|OUT_D,COLOR_YELLOW," Denied (pack locked): ");
+      notice(nick,"** XDCC SEND denied, this pack is locked");
+      goto done;
+    }
   
   tr = irlist_get_head(&gdata.trans);
   while(tr)
@@ -3068,7 +3297,7 @@
   return;
 }
    
-static char* addtoqueue(const char* nick, const char* hostname, int pack)
+char* addtoqueue(const char* nick, const char* hostname, int pack)
 {
    char *tempstr = mycalloc(maxtextlength);
    pqueue *tempq;
@@ -3143,6 +3372,16 @@
   char *sendnamestr;
   
   updatecontext();
+  
+  if (gdata.serverstatus != SERVERSTATUS_CONNECTED)
+     return;
+
+  /* timeout for restart must be less then Transfer Timeout 180s */
+  if (gdata.curtime - gdata.lastservercontact > 150)
+     return;
+  
+  if (gdata.restrictlist && (has_joined_channels(1) == 0))
+     return;
   
   if (!gdata.attop) gototop();
   
diff -dur ../iroffer1.4.b02.orig/src/iroffer_misc.c ./src/iroffer_misc.c
--- ../iroffer1.4.b02.orig/src/iroffer_misc.c	Mon Jan 17 00:17:40 2005
+++ ./src/iroffer_misc.c	Tue May 10 06:25:42 2005
@@ -97,6 +97,15 @@
   {"restrictprivlist",     &gdata.restrictprivlist,     &gdata.restrictprivlist },
   {"restrictsend",         &gdata.restrictsend,         &gdata.restrictsend },
   {"nomd5sum",             &gdata.nomd5sum,             &gdata.nomd5sum },
+  {"getipfromserver",      &gdata.getipfromserver,      &gdata.getipfromserver },
+  {"noduplicatefiles",     &gdata.noduplicatefiles,     &gdata.noduplicatefiles },
+  {"need_voice",           &gdata.need_voice,           &gdata.need_voice },
+  {"hide_list_info",       &gdata.hide_list_info,       &gdata.hide_list_info },
+  {"xdcclist_grouponly",   &gdata.xdcclist_grouponly,   &gdata.xdcclist_grouponly },
+  {"auto_default_group",   &gdata.auto_default_group,   &gdata.auto_default_group },
+  {"restrictprivlistmain", &gdata.restrictprivlistmain, &gdata.restrictprivlistmain },
+  {"restrictprivlistfull", &gdata.restrictprivlistfull, &gdata.restrictprivlistfull },
+  {"groupsincaps",         &gdata.groupsincaps,         &gdata.groupsincaps },
 };
 
 typedef struct
@@ -121,6 +130,7 @@
   {"maxtransfersperperson", &gdata.maxtransfersperperson, &gdata.maxtransfersperperson, 1, 1000000, 1 },
   {"punishslowusers", &gdata.punishslowusers, &gdata.punishslowusers, 0, 1000000, 1 },
   {"autoignore_threshold", &gdata.autoignore_threshold, &gdata.autoignore_threshold, 10, 600, 1 },
+  {"start_of_month",  &gdata.start_of_month,  &gdata.start_of_month,  1, 31, 1 },
 };
 
 typedef struct
@@ -139,8 +149,62 @@
   {"loginname",            &gdata.loginname,            &gdata.loginname },
   {"nickserv_pass",        &gdata.nickserv_pass,        &gdata.nickserv_pass },
   {"restrictprivlistmsg",  &gdata.restrictprivlistmsg,  &gdata.restrictprivlistmsg },
+  {"enable_nick",          &gdata.enable_nick,          &gdata.enable_nick },
+  {"admin_job_file",       &gdata.admin_job_file,       &gdata.admin_job_file },
 };
 
+void update_natip (const char *var)
+{
+  struct hostent *hp;
+  struct in_addr old;
+  struct in_addr in;
+  char *oldtxt;
+
+  if (var == NULL)
+    return;
+
+  bzero((char *)&in, sizeof(in));
+  if (inet_aton(var, &in) == 0)
+    {
+      hp = gethostbyname2(var, AF_INET);
+      if (hp == NULL)
+        {
+          outerror(OUTERROR_TYPE_WARN_LOUD,"Invalid NAT Host, Ignoring: %s",hstrerror(h_errno));
+          return;
+        }
+      if ((unsigned)hp->h_length > sizeof(in) || hp->h_length < 0)
+        {
+          outerror(OUTERROR_TYPE_WARN_LOUD,"Invalid DNS response, Ignoring: %s",hstrerror(h_errno));
+          return;
+        }
+      memcpy(&in, hp->h_addr_list[0], sizeof(in));
+    }
+  
+  old.s_addr = htonl(gdata.ourip);
+  gdata.usenatip = 1;
+  if (old.s_addr == in.s_addr)
+    return;
+  
+  gdata.ourip = ntohl(in.s_addr);
+  oldtxt = strdup(inet_ntoa(old));
+  mylog(CALLTYPE_NORMAL,"DCC IP changed from %s to %s", oldtxt, inet_ntoa(in));
+  free(oldtxt);
+  
+  if (gdata.debug > 0) ioutput(CALLTYPE_NORMAL,OUT_S,COLOR_YELLOW,"ip=0x%8.8lX\n",gdata.ourip);
+  
+  /* check for 10.0.0.0/8 172.16.0.0/12 192.168.0.0/16 */
+  if (((gdata.ourip & 0xFF000000UL) == 0x0A000000UL) ||
+      ((gdata.ourip & 0xFFF00000UL) == 0xAC100000UL) ||
+      ((gdata.ourip & 0xFFFF0000UL) == 0xC0A80000UL))
+    {
+      outerror(OUTERROR_TYPE_WARN_LOUD,"usenatip of %lu.%lu.%lu.%lu looks wrong, this is probably not what you want to do",
+                (gdata.ourip >> 24) & 0xFF,
+                (gdata.ourip >> 16) & 0xFF,
+                (gdata.ourip >>  8) & 0xFF,
+                (gdata.ourip      ) & 0xFF);
+     }
+}
+
 void getconfig_set (const char *line, int rehash)
 {
   char *type;
@@ -350,6 +414,13 @@
        strcpy(cjr, var);
        mydelete(var);
      }
+   else if ( !strcmp(type,"adddir_exclude"))
+     {
+       char *cjr;
+       cjr = irlist_add(&gdata.adddir_exclude, strlen(var) + 1);
+       strcpy(cjr, var);
+       mydelete(var);
+     }
    else if ( ! strcmp(type,"channel")) {
       char *tptr = NULL, *tptr2 = NULL, *tname;
       int ok=1;
@@ -599,35 +670,7 @@
       }
    else if ( ! strcmp(type,"usenatip"))
      {
-      unsigned long ipparts[4];
-      if (sscanf(var, "%lu.%lu.%lu.%lu", &ipparts[0], &ipparts[1], &ipparts[2], &ipparts[3]) < 4)
-        {
-          outerror(OUTERROR_TYPE_WARN_LOUD,"Invalid NAT Host, Ignoring");
-        }
-      else if ((ipparts[0] > 255) || (ipparts[1] > 255) ||
-               (ipparts[2] > 255) || (ipparts[3] > 255))
-        {
-          outerror(OUTERROR_TYPE_WARN_LOUD,"Invalid NAT Host, Ignoring");
-        }
-      else
-        {
-          gdata.usenatip = 1;
-          gdata.ourip = (ipparts[0] << 24) | (ipparts[1] << 16) | (ipparts[2] << 8) | ipparts[3];
-          
-          if (gdata.debug > 0) ioutput(CALLTYPE_NORMAL,OUT_S,COLOR_YELLOW,"ip=0x%8.8lX\n",gdata.ourip);
-          
-          /* check for 10.0.0.0/8 172.16.0.0/12 192.168.0.0/16 */
-          if (((gdata.ourip & 0xFF000000UL) == 0x0A000000UL) ||
-              ((gdata.ourip & 0xFFF00000UL) == 0xAC100000UL) ||
-              ((gdata.ourip & 0xFFFF0000UL) == 0xC0A80000UL))
-            {
-              outerror(OUTERROR_TYPE_WARN_LOUD,"usenatip of %lu.%lu.%lu.%lu looks wrong, this is probably not what you want to do",
-                       (gdata.ourip >> 24) & 0xFF,
-                       (gdata.ourip >> 16) & 0xFF,
-                       (gdata.ourip >>  8) & 0xFF,
-                       (gdata.ourip      ) & 0xFF);
-            }
-        }
+      update_natip(var);
       mydelete(var);
      }
    else if ( ! strcmp(type,"local_vhost"))
@@ -1468,7 +1511,10 @@
   
   uxdl = mycalloc(sizeof(userinput));
   
-  u_fillwith_msg(uxdl,NULL,"A A A A A xdl");
+  if (gdata.xdcclist_grouponly)
+    u_fillwith_msg(uxdl,NULL,"A A A A A xdl");
+  else
+    u_fillwith_msg(uxdl,NULL,"A A A A A xdlfull");
   uxdl->method = method_fd; 
   uxdl->fd = fd;
   
@@ -2323,6 +2369,19 @@
   gdata.lowbdwth = 0;
   gdata.punishslowusers = 0;
   gdata.nomd5sum = 0;
+  gdata.getipfromserver = 0;
+  gdata.noduplicatefiles = 0;
+  irlist_delete_all(&gdata.adddir_exclude);
+  mydelete(gdata.enable_nick);
+  gdata.need_voice = 0;
+  gdata.hide_list_info = 0;
+  gdata.xdcclist_grouponly = 0;
+  gdata.auto_default_group = 0;
+  gdata.start_of_month = 1;
+  gdata.restrictprivlistmain = 0;
+  gdata.restrictprivlistfull = 0;
+  gdata.groupsincaps = 0;
+  mydelete(gdata.admin_job_file);
   gdata.transferminspeed = gdata.transfermaxspeed = 0.0;
   gdata.overallmaxspeed = gdata.overallmaxspeeddayspeed = 0;
   gdata.overallmaxspeeddaytimestart = gdata.overallmaxspeeddaytimeend = 0;
@@ -3025,6 +3084,8 @@
 {
   transfer *tr;
   pqueue *pq;
+  pqueue *old;
+  int userinqueue = 0;
   
   for (tr = irlist_get_head(&gdata.trans); tr; tr = irlist_get_next(tr))
     {
@@ -3046,7 +3107,45 @@
         }
     }
   
+  for (pq = irlist_get_head(&gdata.mainqueue); pq; )
+    {
+      if (!strcasecmp(pq->nick, newnick))
+        {
+	  userinqueue++;
+          if ( userinqueue > gdata.maxqueueditemsperperson )
+            {
+              mydelete(pq->nick);
+              mydelete(pq->hostname);
+	      old = pq;
+              pq = irlist_get_next(pq);
+              irlist_delete(&gdata.mainqueue, old);
+              continue;
+            }
+        }
+      pq = irlist_get_next(pq);
+    }
   return;
+}
+
+int has_joined_channels(int all)
+{
+  int j;
+  channel_t *ch;
+
+  j=0;
+  ch = irlist_get_head(&gdata.channels);
+  while(ch)
+    {
+       if ((ch->flags | CHAN_ONCHAN) == 0)
+         {
+           if (all != 0)
+             return 0;
+         }
+       else
+         j++;
+       ch = irlist_get_next(ch);
+     }
+  return j;
 }
 
 void reverify_restrictsend(void)
diff -dur ../iroffer1.4.b02.orig/src/iroffer_statefile.c ./src/iroffer_statefile.c
--- ../iroffer1.4.b02.orig/src/iroffer_statefile.c	Mon Jan 17 00:17:40 2005
+++ ./src/iroffer_statefile.c	Sun Feb  6 11:28:40 2005
@@ -74,6 +74,9 @@
   STATEFILE_TAG_XDCCS_MINSPEED,
   STATEFILE_TAG_XDCCS_MAXSPEED,
   STATEFILE_TAG_XDCCS_MD5SUM_INFO,
+  STATEFILE_TAG_XDCCS_GROUP,
+  STATEFILE_TAG_XDCCS_GROUP_DESC,
+  STATEFILE_TAG_XDCCS_LOCK,
   
   STATEFILE_TAG_TLIMIT_DAILY_USED    = 13 << 8,
   STATEFILE_TAG_TLIMIT_DAILY_ENDS,
@@ -82,6 +85,11 @@
   STATEFILE_TAG_TLIMIT_MONTHLY_USED,
   STATEFILE_TAG_TLIMIT_MONTHLY_ENDS,
   
+  STATEFILE_TAG_QUEUE                = 14 << 8,
+  STATEFILE_TAG_QUEUE_PACK,
+  STATEFILE_TAG_QUEUE_NICK,
+  STATEFILE_TAG_QUEUE_HOST,
+  STATEFILE_TAG_QUEUE_TIME,
 } statefile_tag_t;
 
 typedef struct
@@ -483,6 +491,18 @@
           {
             length += ceiling(sizeof(statefile_item_md5sum_info_t), 4);
           }
+        if (xd->group != NULL)
+          {
+            length += sizeof(statefile_hdr_t) + ceiling(strlen(xd->group) + 1, 4);
+          }
+        if (xd->group_desc != NULL)
+          {
+            length += sizeof(statefile_hdr_t) + ceiling(strlen(xd->group_desc) + 1, 4);
+          }
+        if (xd->lock != NULL)
+          {
+            length += sizeof(statefile_hdr_t) + ceiling(strlen(xd->lock) + 1, 4);
+          }
         
         data = mycalloc(length);
         
@@ -567,6 +587,37 @@
             memcpy(md5sum_info->md5sum, xd->md5sum, sizeof(MD5Digest));
             next = (unsigned char*)(&md5sum_info[1]);
           }
+
+        if (xd->group != NULL)
+          {
+            /* group */
+            hdr = (statefile_hdr_t*)next;
+            hdr->tag = htonl(STATEFILE_TAG_XDCCS_GROUP);
+            hdr->length = htonl(sizeof(statefile_hdr_t) + strlen(xd->group) + 1);
+            next = (unsigned char*)(&hdr[1]);
+            strcpy(next, xd->group);
+            next += ceiling(strlen(xd->group) + 1, 4);
+          }
+        if (xd->group_desc != NULL)
+          {
+            /* group_desc */
+            hdr = (statefile_hdr_t*)next;
+            hdr->tag = htonl(STATEFILE_TAG_XDCCS_GROUP_DESC);
+            hdr->length = htonl(sizeof(statefile_hdr_t) + strlen(xd->group_desc) + 1);
+            next = (unsigned char*)(&hdr[1]);
+            strcpy(next, xd->group_desc);
+            next += ceiling(strlen(xd->group_desc) + 1, 4);
+          }
+        if (xd->lock != NULL)
+          {
+            /* group */
+            hdr = (statefile_hdr_t*)next;
+            hdr->tag = htonl(STATEFILE_TAG_XDCCS_LOCK);
+            hdr->length = htonl(sizeof(statefile_hdr_t) + strlen(xd->lock) + 1);
+            next = (unsigned char*)(&hdr[1]);
+            strcpy(next, xd->lock);
+            next += ceiling(strlen(xd->lock) + 1, 4);
+          }
         
         write_statefile_item(&bout, data);
         
@@ -622,6 +673,86 @@
     item_monthly_ends.g_time = htonl(gdata.transferlimits[TRANSFERLIMIT_MONTHLY].ends);
     write_statefile_item(&bout, &item_monthly_ends);
   }
+  {
+    unsigned char *data;
+    unsigned char *next;
+    pqueue *pq;
+    xdcc *xd;
+    statefile_item_generic_int_t *g_int;
+    statefile_item_generic_time_t *g_time;
+    int pack;
+    
+    pq = irlist_get_head(&gdata.mainqueue);
+    
+    while (pq)
+      {
+        /*
+         * need room to write:
+         *  pack          int
+         *  nick          string
+         *  hostname      string
+         *  queuedtime    time
+         */
+        length = sizeof(statefile_hdr_t) +
+          sizeof(statefile_item_generic_int_t) + 
+          sizeof(statefile_hdr_t) + ceiling(strlen(pq->nick) + 1, 4) +
+          sizeof(statefile_hdr_t) + ceiling(strlen(pq->hostname) + 1, 4) +
+          sizeof(statefile_item_generic_time_t);
+        
+        data = mycalloc(length);
+        
+        /* outter header */
+        hdr = (statefile_hdr_t*)data;
+        hdr->tag = STATEFILE_TAG_QUEUE;
+        hdr->length = length;
+        next = (unsigned char*)(&hdr[1]);
+
+        pack = 1;
+        xd = irlist_get_head(&gdata.xdccs);
+        while(xd)
+          {
+            if (xd == pq->xpack)
+              break;
+            pack++;
+            xd = irlist_get_next(xd);
+          }
+
+        /* pack */
+        g_int = (statefile_item_generic_int_t*)next;
+        g_int->hdr.tag = htonl(STATEFILE_TAG_QUEUE_PACK);
+        g_int->hdr.length = htonl(sizeof(*g_int));
+        g_int->g_int = htonl(pack);
+        next = (unsigned char*)(&g_int[1]);
+        
+        /* nick */
+        hdr = (statefile_hdr_t*)next;
+        hdr->tag = htonl(STATEFILE_TAG_QUEUE_NICK);
+        hdr->length = htonl(sizeof(statefile_hdr_t) + strlen(pq->nick) + 1);
+        next = (unsigned char*)(&hdr[1]);
+        strcpy(next, pq->nick);
+        next += ceiling(strlen(pq->nick) + 1, 4);
+        
+        /* hostname */
+        hdr = (statefile_hdr_t*)next;
+        hdr->tag = htonl(STATEFILE_TAG_QUEUE_HOST);
+        hdr->length = htonl(sizeof(statefile_hdr_t) + strlen(pq->hostname) + 1);
+        next = (unsigned char*)(&hdr[1]);
+        strcpy(next, pq->hostname);
+        next += ceiling(strlen(pq->hostname) + 1, 4);
+        
+        /* queuedtime */
+        g_time = (statefile_item_generic_time_t*)next;
+        g_time->hdr.tag = htonl(STATEFILE_TAG_QUEUE_TIME);
+        g_time->hdr.length = htonl(sizeof(*g_time));
+        g_time->g_time = htonl(pq->queuedtime);
+        next = (unsigned char*)(&g_time[1]);
+        
+        write_statefile_item(&bout, data);
+        
+        mydelete(data);
+        pq = irlist_get_next(pq);
+      }
+  }
   
   {
     MD5Digest digest = {};
@@ -1157,6 +1288,9 @@
             
             xd->minspeed = gdata.transferminspeed;
             xd->maxspeed = gdata.transfermaxspeed;
+            xd->group = NULL;
+            xd->group_desc = NULL;
+            xd->lock = NULL;
             
             hdr->length -= sizeof(*hdr);
             ihdr = &hdr[1];
@@ -1276,6 +1410,51 @@
                       }
                     break;
                     
+                  case STATEFILE_TAG_XDCCS_GROUP:
+                    if (ihdr->length > sizeof(statefile_hdr_t))
+                      {
+                        char *group = (char*)(&ihdr[1]);
+                        group[ihdr->length-sizeof(statefile_hdr_t)-1] = '\0';
+                        xd->group = mycalloc(strlen(group)+1);
+                        strcpy(xd->group,group);
+                      }
+                    else
+                      {
+                        outerror(OUTERROR_TYPE_WARN, "Ignoring Bad XDCC Desc Tag (len = %d)",
+                                 ihdr->length);
+                      }
+                    break;
+                    
+                  case STATEFILE_TAG_XDCCS_GROUP_DESC:
+                    if (ihdr->length > sizeof(statefile_hdr_t))
+                      {
+                        char *group_desc = (char*)(&ihdr[1]);
+                        group_desc[ihdr->length-sizeof(statefile_hdr_t)-1] = '\0';
+                        xd->group_desc = mycalloc(strlen(group_desc)+1);
+                        strcpy(xd->group_desc,group_desc);
+                      }
+                    else
+                      {
+                        outerror(OUTERROR_TYPE_WARN, "Ignoring Bad XDCC Desc Tag (len = %d)",
+                                 ihdr->length);
+                      }
+                    break;
+                    
+                  case STATEFILE_TAG_XDCCS_LOCK:
+                    if (ihdr->length > sizeof(statefile_hdr_t))
+                      {
+                        char *data = (char*)(&ihdr[1]);
+                        data[ihdr->length-sizeof(statefile_hdr_t)-1] = '\0';
+                        xd->lock = mycalloc(strlen(data)+1);
+                        strcpy(xd->lock,data);
+                      }
+                    else
+                      {
+                        outerror(OUTERROR_TYPE_WARN, "Ignoring Bad XDCC Lock Tag (len = %d)",
+                                 ihdr->length);
+                      }
+                    break;
+                    
                   default:
                     outerror(OUTERROR_TYPE_WARN, "Ignoring Unknown XDCC Tag 0x%X (len=%d)",
                              ihdr->tag, ihdr->length);
@@ -1477,6 +1656,96 @@
             }
           break;
           
+        case STATEFILE_TAG_QUEUE:
+          {
+            pqueue *pq;
+            statefile_hdr_t *ihdr;
+            statefile_item_generic_int_t *g_int;
+            statefile_item_generic_time_t *g_time;
+            char *text;
+            int num;
+            
+            pq = irlist_add(&gdata.mainqueue, sizeof(pqueue));
+
+            pq->xpack = NULL;
+            pq->nick = NULL;
+            pq->hostname = NULL;
+            pq->queuedtime = 0L;
+            pq->restrictsend_bad = gdata.curtime;
+            
+            hdr->length -= sizeof(*hdr);
+            ihdr = &hdr[1];
+            
+            while (hdr->length >= sizeof(*hdr))
+              {
+                ihdr->tag = ntohl(ihdr->tag);
+                ihdr->length = ntohl(ihdr->length);
+                switch (ihdr->tag)
+                  {
+                  case STATEFILE_TAG_QUEUE_PACK:
+                    if (ihdr->length != sizeof(statefile_item_generic_int_t))
+                      {
+                        outerror(OUTERROR_TYPE_WARN, "Ignoring Bad Queue Pack Tag (len = %d)",
+                                 ihdr->length);
+                        break;
+                      }
+                    g_int = (statefile_item_generic_int_t*)ihdr;
+                    num = ntohl(g_int->g_int);
+                    if (num < 1 || num > irlist_size(&gdata.xdccs))
+                      {
+                        outerror(OUTERROR_TYPE_WARN, "Ignoring Bad Queue Pack Nr (%d)", num);
+                        break;
+                      }
+                    pq->xpack = irlist_get_nth(&gdata.xdccs, num-1);
+                    break;
+                    
+                  case STATEFILE_TAG_QUEUE_NICK:
+                    if (ihdr->length <= sizeof(statefile_hdr_t))
+                      {
+                        outerror(OUTERROR_TYPE_WARN, "Ignoring Bad Queue Nick Tag (len = %d)",
+                                 ihdr->length);
+                        break;
+                      }
+                    text = (char*)(&ihdr[1]);
+                    text[ihdr->length-sizeof(statefile_hdr_t)-1] = '\0';
+                    pq->nick = mycalloc(strlen(text)+1);
+                    strcpy(pq->nick,text);
+                    break;
+                    
+                  case STATEFILE_TAG_QUEUE_HOST:
+                    if (ihdr->length <= sizeof(statefile_hdr_t))
+                      {
+                        outerror(OUTERROR_TYPE_WARN, "Ignoring Bad Queue Host Tag (len = %d)",
+                                 ihdr->length);
+                        break;
+                      }
+                    text = (char*)(&ihdr[1]);
+                    text[ihdr->length-sizeof(statefile_hdr_t)-1] = '\0';
+                    pq->hostname = mycalloc(strlen(text)+1);
+                    strcpy(pq->hostname,text);
+                    break;
+                    
+                  case STATEFILE_TAG_QUEUE_TIME:
+                    if (ihdr->length != sizeof(statefile_item_generic_time_t))
+                      {
+                        outerror(OUTERROR_TYPE_WARN, "Ignoring Bad Queue Time Tag (len = %d)",
+                                 ihdr->length);
+                        break;
+                      }
+                    g_time = (statefile_item_generic_time_t*)ihdr;
+                    pq->queuedtime = ntohl(g_time->g_time);
+                    break;
+                    
+                  default:
+                    outerror(OUTERROR_TYPE_WARN, "Ignoring Unknown XDCC Tag 0x%X (len=%d)",
+                             ihdr->tag, ihdr->length);
+                  }
+                hdr->length -= ceiling(ihdr->length, 4);
+                ihdr = (statefile_hdr_t*)(((char*)ihdr) + ceiling(ihdr->length, 4));
+              }
+          }
+          break;
+
         default:
           outerror(OUTERROR_TYPE_WARN, "Ignoring Unknown Tag 0x%X (len=%d)",
                  hdr->tag, hdr->length);
@@ -1514,6 +1783,14 @@
               COLOR_NO_COLOR, "  [Found %d Pack%s]",
               irlist_size(&gdata.xdccs),
               (irlist_size(&gdata.xdccs) == 1) ? "" : "s");
+    }
+  
+  if ((gdata.debug > 0) || irlist_size(&gdata.mainqueue))
+    {
+      ioutput(CALLTYPE_NORMAL, OUT_S|OUT_L|OUT_D,
+              COLOR_NO_COLOR, "  [Found %d Queue%s]",
+              irlist_size(&gdata.mainqueue),
+              (irlist_size(&gdata.mainqueue) == 1) ? "" : "s");
     }
   
   ioutput(CALLTYPE_NORMAL, OUT_S|OUT_L|OUT_D,
diff -dur ../iroffer1.4.b02.orig/src/iroffer_utilities.c ./src/iroffer_utilities.c
--- ../iroffer1.4.b02.orig/src/iroffer_utilities.c	Mon Jan 17 00:17:40 2005
+++ ./src/iroffer_utilities.c	Thu May 19 07:00:50 2005
@@ -1069,7 +1069,7 @@
    
    if (i == (MEMINFOHASHSIZE * gdata.meminfo_depth)) {
       outerror(OUTERROR_TYPE_WARN_LOUD,"Pointer 0x%8.8lX not found in meminfo database while trying to free!!",(long)t);
-      outerror(OUTERROR_TYPE_WARN_LOUD,"Please report this error to PMG");
+      outerror(OUTERROR_TYPE_WARN_LOUD,"Please report this error to Dinoex");
       for(i=0; i<(12*12); i+=12) {
          outerror(OUTERROR_TYPE_WARN_LOUD," : %2.2X %2.2X %2.2X %2.2X %2.2X %2.2X %2.2X %2.2X %2.2X %2.2X %2.2X %2.2X = \"%c%c%c%c%c%c%c%c%c%c%c%c\"",
                ut[i+0], ut[i+1], ut[i+2], ut[i+3], ut[i+4], ut[i+5], ut[i+6], ut[i+7], ut[i+8], ut[i+9], ut[i+10], ut[i+11],
@@ -1420,6 +1420,19 @@
   gdata_print_int(maxqueueditemsperperson);
   gdata_print_int(punishslowusers);
   gdata_print_int(nomd5sum);
+  gdata_print_int(getipfromserver);
+  gdata_print_int(noduplicatefiles);
+  /* adddir_exclude */
+  gdata_print_string(enable_nick);
+  gdata_print_int(need_voice);
+  gdata_print_int(hide_list_info);
+  gdata_print_int(xdcclist_grouponly);
+  gdata_print_int(auto_default_group);
+  gdata_print_int(start_of_month);
+  gdata_print_int(restrictprivlistmain);
+  gdata_print_int(restrictprivlistfull);
+  gdata_print_int(groupsincaps);
+  gdata_print_string(admin_job_file);
   
   /* downloadhost */
   
@@ -1883,6 +1896,9 @@
 
 void changeinmemberlist(channel_t *c, char *oldnick, const char *newnick)
 {
+  char *nick1;
+  char *member;
+
   updatecontext();
   
   if (gdata.debug > 2)
@@ -1891,6 +1907,27 @@
               "changing %s to %s in %s",oldnick,newnick,c->name);
     }
   
+  if (gdata.need_voice)
+    {
+      nick1 = mycalloc(strlen(oldnick)+1);
+      strcpy(nick1,oldnick);
+      caps(nick1);
+  
+      /* is in list for this channel? */
+      member = irlist_get_head(&c->members);
+      while(member)
+        {
+          if (!strcmp(caps(member),oldnick))
+            {
+              irlist_delete(&c->members, member);
+              addtomemberlist(c, newnick);
+              return;
+            }
+          member = irlist_get_next(member);
+        }
+        return;
+    }
+    
   removefrommemberlist(c, oldnick);
   addtomemberlist(c, newnick);
   
Only in .: t.sh
Only in .: z.sh