#include "billingkom.h"

void dosubscribe(struct group *group)
{

   char buf[300];

   sprintf(buf,"%s.Subscribed.%s",BASENAME,group->umsgroup);

   group->subscribed=TRUE;
   writesubscribed();

   ownprintf(strings[STR_SUBGROUP],group->komname);
}

void dounsubscribe(struct group *group)
{
   char buf[300];

   sprintf(buf,"%s.Subscribed.%s",BASENAME,group->umsgroup);

   group->subscribed=FALSE;
   writesubscribed();

   ownprintf(strings[STR_UNSUBGROUP],group->komname);
}

/*********************************************************************/

/************************ KOMmands ***********************************/

void kom_quit(char *arg,char *data)
{
   exitkom=TRUE;
}

void kom_where(char *arg, char *data)
{
   long res;
   char *plural;
   char groupname[200],rawgroupname[200],buf[400];

   res=countnewgroup(currentgroup,currentfolder);

   makegroup(groupname,currentgroup,currentfolder);
   rawmakegroup(rawgroupname,currentgroup,currentfolder);

   if(stricmp(groupname,rawgroupname)==0)
      strcpy(buf,groupname);
   else
      sprintf(buf,"%s (%s)",groupname,rawgroupname);

   if(res == 1)
      plural=strings[STR_UNREADTEXT];
   else
      plural=strings[STR_UNREADTEXTS];

   ownprintf(strings[STR_WHERE],
      buf,
      res,
      plural);
}

void kom_showtime(char *arg,char *data)
{
   time_t t = time(NULL);
   struct tm *tp = localtime(&t);

   ownprintf(strings[STR_TIME],
      strings[STR_SUNDAY+tp->tm_wday],
      tp->tm_mday,
      strings[STR_JANUARY+tp->tm_mon],
      tp->tm_year+1900,
      tp->tm_hour,
      tp->tm_min,
      tp->tm_sec);
}

void kom_showversion(char *arg,char *data)
{
   ownprintf(strings[STR_VERSION],BASENAME,VERSION,__DATE__);
}

void kom_nextgroup(char *arg,char *data)
{
   struct group *group;

   if(group=findnextgroup())
   {
      mystrncpy(currentgroup,group->umsgroup,sizeof(currentgroup));
      mystrncpy(currentfolder,group->umsfolder,sizeof(currentfolder));
   }

   readarraynum=0;

   kom_where(NULL,NULL);
}

void kom_listsubjects(char *arg,char *data)
{
   long lastnum,res,chainup,userflags;
   char *fromname,*subject,ast;

   umsflag_clear();
   umsflag_selectnew();
   umsflag_selectnewgroup(currentgroup,currentfolder);

   linesonscreen=0;
   lastnum=0;
   brk=FALSE;

   ownprintf("  %-7.7s %-30.30s %.*s\n\n",
      strings[STR_LISTNR],
      strings[STR_LISTFROM],
      currentwidth-2-7-1-30-1,
      strings[STR_LISTSUBJECT]);

   while(!brk)
   {
      lastnum=UMSSearchTags(login,UMSTAG_SearchLocal, TRUE,
                                  UMSTAG_SearchLast,  lastnum,
                                  UMSTAG_SearchMask,  UMSFLAG_SELECTED,
                                  UMSTAG_SearchMatch, UMSFLAG_SELECTED,
                                  TAG_DONE);

      if(!lastnum)
         return;

      res=UMSReadMsgTags(login,UMSTAG_RMsgNum,       lastnum,
                               UMSTAG_RFromName,     &fromname,
                               UMSTAG_RSubject,      &subject,
                               UMSTAG_RChainUp,      &chainup,
                               TAG_DONE);

      if(!subject) subject="";

      if(res)
      {
         ast=' ';

         if(chainup)
            if(UMSReadMsgTags(login,UMSTAG_RMsgNum,chainup,UMSTAG_RUserFlags,&userflags,TAG_DONE))
            {
               if(userflags & UMSUSTATF_Owner) ast='*';
               UMSFreeMsg(login,chainup);
            }

         ownprintf("%c %-7ld %-30.30s %.*s\n",
            ast,
            lastnum,
            fromname,
            currentwidth-2-7-1-30-1,
            subject);

         UMSFreeMsg(login,lastnum);
      }
      else
      {
         ownprintf("%-7ld %s\n",lastnum,strings[STR_TEXTNOTEXIST]);
      }
   }

   printf(strings[STR_BREAK]);
}

void kom_listparked(char *arg,char *data)
{
   long lastnum,res;
   char *subject,*group,*folder;
   char groupname[200];

   linesonscreen=0;
   lastnum=0;
   brk=FALSE;

   umsflag_clear();
   res=umsflag_selectparked();

   ownprintf("%-7.7s %-30.30s %.*s\n\n",
      strings[STR_LISTNR],
      strings[STR_LISTGROUP],
      currentwidth-7-1-30-1,
      strings[STR_LISTSUBJECT]);

   while(!brk)
   {
      lastnum=UMSSearchTags(login,UMSTAG_SearchLocal, TRUE,
                                  UMSTAG_SearchLast,  lastnum,
                                  UMSTAG_SearchMask,  UMSFLAG_SELECTED,
                                  UMSTAG_SearchMatch, UMSFLAG_SELECTED,
                                  TAG_DONE);

      if(!lastnum)
         return;

      res=UMSReadMsgTags(login,UMSTAG_RMsgNum,       lastnum,
                               UMSTAG_RGroup,        &group,
                               UMSTAG_RFolder,       &folder,
                               UMSTAG_RSubject,      &subject,
                               TAG_DONE);

      if(res)
      {
         if(!subject) subject="";
         makegroup(groupname,group,folder);

         ownprintf("%-7ld %-30.30s %.*s\n",
            lastnum,
            groupname,
            currentwidth-7-1-30-1,
            subject);

         UMSFreeMsg(login,lastnum);
      }
      else
      {
         ownprintf("%-7ld %s\n",lastnum,strings[STR_TEXTNOTEXIST]);
      }
   }

   printf(strings[STR_BREAK]);
}

void kom_listunread(char *arg,char *data)
{
   struct group *group;
   long new,total,totnew,c,toyou;
   char *thing="|/-\\";
   char ast;
   bool res;

   linesonscreen=0;
   brk=FALSE;

   ownprintf("  %7.7s %7.7s  %s\n",
      strings[STR_GROUPUNREAD],
      strings[STR_GROUPTOT],
      strings[STR_GROUPNAME]);

   ownprintf("\n");
   totnew=0;

   group=firstgroup;

   umsflag_clear();
   umsflag_selectnew();

   c=0;

   while(!brk)
   {
      if(!group)
      {
         ownprintf("\n");

         if(totnew == 0)
            ownprintf(strings[STR_LISTTOTUNREADNO],totnew);

         if(totnew == 1)
            ownprintf(strings[STR_LISTTOTUNREAD],totnew);

         else
            ownprintf(strings[STR_LISTTOTUNREADS],totnew);

         return;
      }

      if(group->access && group->subscribed)
      {
         printf("%lc",thing[c]);
         fflush(stdout);
         c++;
         if(c==4) c=0;

         res=groupunread(group->umsgroup,group->umsfolder);

         printf("\x08 \x08");

         if(res)
         {
            umsflag_clear();
            umsflag_selectnew();

            UMSSelectTags(login,UMSTAG_SelWriteLocal, TRUE,
                                UMSTAG_SelQuick,      TRUE,
                                UMSTAG_WGroup,        group->umsgroup,
                                UMSTAG_SelSet,        UMSFLAG_CURRENTAREA,
                                UMSTAG_SelUnset,      0,
                                TAG_DONE);

            UMSSelectTags(login,UMSTAG_SelWriteLocal, TRUE,
                                UMSTAG_SelQuick,      TRUE,
                                UMSTAG_WFolder,       group->umsfolder,
                                UMSTAG_SelSet,        UMSFLAG_CURRENTFOLDER,
                                UMSTAG_SelUnset,      0,
                                TAG_DONE);

            UMSSelectTags(login,UMSTAG_SelWriteLocal, TRUE,
                                UMSTAG_SelParent,     1,
                                UMSTAG_SelMask,       UMSUSTATF_Owner,
                                UMSTAG_SelMatch,      UMSUSTATF_Owner,
                                UMSTAG_SelSet,        UMSFLAG_OWNER,
                                UMSTAG_SelUnset,      0,
                                TAG_DONE);

            total=UMSSelectTags(login,UMSTAG_SelWriteLocal, TRUE,
                                      UMSTAG_SelReadLocal,  TRUE,
                                      UMSTAG_SelMask,       UMSFLAG_CURRENTAREA | UMSFLAG_CURRENTFOLDER,
                                      UMSTAG_SelMatch,      UMSFLAG_CURRENTAREA | UMSFLAG_CURRENTFOLDER,
                                      TAG_DONE);

            new=UMSSelectTags(login,UMSTAG_SelWriteLocal, TRUE,
                                    UMSTAG_SelReadLocal,  TRUE,
                                    UMSTAG_SelMask,       UMSFLAG_NEW | UMSFLAG_CURRENTAREA | UMSFLAG_CURRENTFOLDER,
                                    UMSTAG_SelMatch,      UMSFLAG_NEW | UMSFLAG_CURRENTAREA | UMSFLAG_CURRENTFOLDER,
                                    TAG_DONE);

            toyou=UMSSelectTags(login,UMSTAG_SelWriteLocal, TRUE,
                                      UMSTAG_SelReadLocal,  TRUE,
                                      UMSTAG_SelMask,       UMSFLAG_OWNER | UMSFLAG_NEW | UMSFLAG_CURRENTAREA | UMSFLAG_CURRENTFOLDER,
                                      UMSTAG_SelMatch,      UMSFLAG_OWNER | UMSFLAG_NEW | UMSFLAG_CURRENTAREA | UMSFLAG_CURRENTFOLDER,
                                      TAG_DONE);

            ast=' ';
            if(toyou) ast='*';

            ownprintf("%c %7ld %7ld  %s\n",
               ast,
               new,
               total,
               group->komname);

            totnew+=new;

            umsflag_clear();
            umsflag_selectnew();
            fflush(stdout);
         }
      }
      group=group->next;
   }

   printf(strings[STR_BREAK]);
}

void kom_listgroups(char *arg,char *data)
{
   struct group *group;
   long new,total;
   char ast;
   bool match;
   
   linesonscreen=0;
   brk=FALSE;

   ownprintf("  %7.7s %7.7s  %s\n",
      strings[STR_GROUPUNREAD],
      strings[STR_GROUPTOT],
      strings[STR_GROUPNAME]);

   ownprintf("\n");

   group=firstgroup;

   while(!brk)
   {
      if(!group)
         return;

      match=FALSE;

      if(!arg) match=TRUE;
      else if(ownstristr(group->komname,arg)) match=TRUE;

      if(group->access && match)
      {
         umsflag_clear();
         umsflag_selectnew();

         UMSSelectTags(login,UMSTAG_SelWriteLocal, TRUE,
                             UMSTAG_SelQuick,      TRUE,
                             UMSTAG_WGroup,        group->umsgroup,
                             UMSTAG_SelSet,        UMSFLAG_CURRENTAREA,
                             UMSTAG_SelUnset,      0,
                             TAG_DONE);

         UMSSelectTags(login,UMSTAG_SelWriteLocal, TRUE,
                             UMSTAG_SelQuick,      TRUE,
                             UMSTAG_WFolder,       group->umsfolder,
                             UMSTAG_SelSet,        UMSFLAG_CURRENTFOLDER,
                             UMSTAG_SelUnset,      0,
                             TAG_DONE);

         total=UMSSelectTags(login,UMSTAG_SelWriteLocal, TRUE,
                                   UMSTAG_SelReadLocal,  TRUE,
                                   UMSTAG_SelMask,       UMSFLAG_CURRENTAREA | UMSFLAG_CURRENTFOLDER,
                                   UMSTAG_SelMatch,      UMSFLAG_CURRENTAREA | UMSFLAG_CURRENTFOLDER,
                                   TAG_DONE);

         new=UMSSelectTags(login,UMSTAG_SelWriteLocal, TRUE,
                                 UMSTAG_SelReadLocal,  TRUE,
                                 UMSTAG_SelMask,       UMSFLAG_NEW | UMSFLAG_CURRENTAREA | UMSFLAG_CURRENTFOLDER,
                                 UMSTAG_SelMatch,      UMSFLAG_NEW | UMSFLAG_CURRENTAREA | UMSFLAG_CURRENTFOLDER,
                                 TAG_DONE);

         ast=' ';

         if(group->subscribed)
            ast='*';

         ownprintf(" %c%7ld %7ld  %s\n",
            ast,
            new,
            total,
            group->komname);
      }
      group=group->next;
   }

   printf(strings[STR_BREAK]);
}

void kom_skiptree(char *arg,char *data)
{
   if(!lastread)
   {
      printf(strings[STR_NOTREADTEXTS]);
      return;
   }

   UMSSelectTags(login,UMSTAG_SelTree,      lastread,
                       UMSTAG_SelSet,       UMSUSTATF_Old,
                       UMSTAG_SelUnset,     0,
                       TAG_DONE);

   kom_where(NULL,NULL);

   readarraynum=0;
}

void kom_listcommands(char *arg,char *data)
{
   struct command *command;

   brk=FALSE;
   linesonscreen=0;

   for(command=firstcommand;command && !brk;command=command->next)
      ownprintf("%s\n",command->command);

   if(brk)
      printf(strings[STR_BREAK]);
}

void kom_showfile(char *arg,char *data)
{
   FILE *fp;
   char s[1000];

   if(!(fp=fopen(data,"r")))
   {
      printf("Can't read file %s\n",data);
      return;
   }

   brk=FALSE;
   linesonscreen=0;

   while(fgets(s,999,fp) && !brk)
   {
      if(s[0] != 0)
         s[strlen(s)-1]=0;

      ownprintf("%s\n",s);
   }

   fclose(fp);

   if(brk)
   {
      printf("\n");
      printf(strings[STR_BREAK]);
   }
}

void kom_showhelp(char *arg,char *data)
{
   struct command *matchcmd;
   char *temparg;
   char filebuf[200];
   FILE *fp;
   char s[1000];
   long c,d,e;

   if(!arg)
   {
      printf(strings[STR_NEEDSARG]);
      return;
   }

   matchcmd=expandcommand(arg,&temparg,firstcommand);

   if(!matchcmd)
      return;

   for(e=0;commandnames[e].name;e++)
      if(commandnames[e].func == matchcmd->func) break;

   if(!commandnames[e].name)
      return;

   d=0;
   for(c=0;c<strlen(data) && d!=sizeof(filebuf)-1;c++)
   {
      if(data[c]=='%' && (data[c+1]|32)=='c')
      {
         strncpy(&filebuf[d],commandnames[e].name,(size_t)(sizeof(filebuf)-1-d));
         filebuf[sizeof(filebuf)-1]=0;
         d=strlen(filebuf);
         c++;
      }
      else filebuf[d++]=data[c];
   }
   filebuf[d]=0;

   if(!(fp=fopen(filebuf,"r")))
   {
      printf(strings[STR_NOHELP]);
      return;
   }

   brk=FALSE;
   linesonscreen=0;

   while(fgets(s,999,fp) && !brk)
   {
      if(s[0] != 0)
         s[strlen(s)-1]=0;

      ownprintf("%s\n",s);
   }

   fclose(fp);

   if(brk)
   {
      printf("\n");
      printf(strings[STR_BREAK]);
   }
}

void kom_setunread(char *arg,char *data)
{
   if(!arg)
   {
      printf(strings[STR_NEEDSARG]);
      return;
   }

   if(!isnum(arg))
   {
      printf(strings[STR_NEEDSNUMARG]);
      return;
   }

   umsflag_clear();
   umsflag_selectgroup(currentgroup,currentfolder);

   /* Make all unread */

   UMSSelectTags(login,UMSTAG_SelReadLocal,  TRUE,
                       UMSTAG_SelMask,       UMSFLAG_SELECTED,
                       UMSTAG_SelMatch,      UMSFLAG_SELECTED,
                       UMSTAG_SelSet,        UMSUSTATF_Old,
                       TAG_DONE);

   /* Make unread */

   if(atoi(arg))
      UMSSelectTags(login,UMSTAG_SelReadLocal,  TRUE,
                          UMSTAG_SelMask,       UMSFLAG_SELECTED,
                          UMSTAG_SelMatch,      UMSFLAG_SELECTED,
                          UMSTAG_SelUnset,      UMSUSTATF_Old,
                          UMSTAG_SelMaxCount,   atoi(arg),
                          TAG_DONE);

   readarraynum=0;

   kom_where(NULL,NULL);
}

void kom_gotogroup(char *arg,char *data)
{
   struct group *group;

   if(!arg)
   {
      printf(strings[STR_NEEDSARG]);
      return;
   }

   if(!(group=expandgroup(arg)))
      return;

   mystrncpy(currentgroup,group->umsgroup,sizeof(currentgroup));
   mystrncpy(currentfolder,group->umsfolder,sizeof(currentfolder));

   readarraynum=0;

   kom_where(NULL,NULL);
}

void kom_postpone(char *arg,char *data)
{
   long num,res,userflags;

   if(!getargorlast(arg,&num))
      return;

   res=UMSReadMsgTags(login,UMSTAG_RMsgNum,     num,
                            UMSTAG_RUserFlags,  &userflags,
                            TAG_END);

   if(!res)
   {
      printf(strings[STR_TEXTNRNOTEXIST],num);
      return;
   }

   if(userflags & UMSUSTATF_PostPoned)
   {
      printf(strings[STR_ALREADYPOSTPONED],num);
      return;
   }

   res=UMSSelectTags(login,UMSTAG_SelMsg,        num,
                           UMSTAG_SelSet,        UMSUSTATF_PostPoned,
                           TAG_DONE);

   if(res)
      printf(strings[STR_POSTPONEDOK],num);

   else
      printf(strings[STR_POSTPONEDFAIL],num);
}

void kom_postponedunread(char *arg,char *data)
{
   long res;

   res=UMSSelectTags(login,UMSTAG_SelMask,       UMSUSTATF_PostPoned,
                           UMSTAG_SelMatch,      UMSUSTATF_PostPoned,
                           UMSTAG_SelUnset,      UMSUSTATF_Old | UMSUSTATF_PostPoned,
                           TAG_DONE);

   if(res == 1)
      printf(strings[STR_POSTPONEDUNREAD],res);

   else
      printf(strings[STR_POSTPONEDUNREADS],res);
}

void kom_deletemessage(char *arg,char *data)
{
   long num,res;
   char s[100];

   if(!getargorlast(arg,&num))
      return;

   printf(strings[STR_SUREDELETE],num);
   printf(" ");
   fflush(stdout);
   osreadline(s,100);
   printf("\n");

   if(stricmp(s,strings[STR_YES])!=0)
      return;

   res=UMSDeleteMsg(login,num);

   if(res)
      printf(strings[STR_DELETEDOK],num);

   else
      printf(strings[STR_DELETEDFAIL],num);
}

void kom_screenlength(char *arg,char *data)
{
   char buf[50];

   if(arg)
   {
      if(!isnum(arg))
      {
         printf(strings[STR_NEEDSNUMARG]);
         return;
      }

      if(atoi(arg) < 10 || atoi(arg) > 200)
      {
         printf(strings[STR_NROUTOFRANGE],10,200);
         return;
      }

      cfg_Lines=atoi(arg);

      sprintf(buf,"%ld",cfg_Lines);

      UMSWriteConfigTags(login,UMSTAG_CfgName,  BASENAME".ScreenLength",
                               UMSTAG_CfgData,  buf,
                               TAG_DONE);
   }

   printf(strings[STR_SCREENLENGTHNR],cfg_Lines);
}

void kom_linewidth(char *arg,char *data)
{
   char buf[50];

   if(arg)
   {
      if(!isnum(arg))
      {
         printf(strings[STR_NEEDSNUMARG]);
         return;
      }

      if(atoi(arg) < 50 || atoi(arg) > 200)
      {
         printf(strings[STR_NROUTOFRANGE],50,200);
         return;
      }

      cfg_Width=atoi(arg);

      sprintf(buf,"%ld",cfg_Width);

      UMSWriteConfigTags(login,UMSTAG_CfgName,  BASENAME".LineWidth",
                               UMSTAG_CfgData,  buf,
                               TAG_DONE);
   }

   printf(strings[STR_LINEWIDTHNR],cfg_Width);
}


char execbuf[1000];

void kom_execute(char *arg,char *data)
{
   long c,d;
   char lines[10],cols[10];

   if(!arg)
      arg="";

   sprintf(lines,"%d",cfg_Lines);
   sprintf(cols,"%d",cfg_Width);

   d=0;
   for(c=0;c<strlen(data) && d!=sizeof(execbuf)-1;c++)
   {
      if(data[c]=='%' && (data[c+1]|32)=='u')
      {
         strncpy(&execbuf[d],realname,(size_t)(sizeof(execbuf)-1-d));
         execbuf[sizeof(execbuf)-1]=0;
         d=strlen(execbuf);
         c++;
      }
      else if(data[c]=='%' && (data[c+1]|32)=='n')
      {
         strncpy(&execbuf[d],loginusername,(size_t)(sizeof(execbuf)-1-d));
         execbuf[sizeof(execbuf)-1]=0;
         d=strlen(execbuf);
         c++;
      }
      else if(data[c]=='%' && (data[c+1]|32)=='p')
      {
         strncpy(&execbuf[d],loginpassword,(size_t)(sizeof(execbuf)-1-d));
         execbuf[sizeof(execbuf)-1]=0;
         d=strlen(execbuf);
         c++;
      }
      else if(data[c]=='%' && (data[c+1]|32)=='a')
      {
         strncpy(&execbuf[d],arg,(size_t)(sizeof(execbuf)-1-d));
         execbuf[sizeof(execbuf)-1]=0;
         d=strlen(execbuf);
         c++;
      }
      else if(data[c]=='%' && (data[c+1]|32)=='l')
      {
         strncpy(&execbuf[d],lines,(size_t)(sizeof(execbuf)-1-d));
         execbuf[sizeof(execbuf)-1]=0;
         d=strlen(execbuf);
         c++;
      }
      else if(data[c]=='%' && (data[c+1]|32)=='c')
      {
         strncpy(&execbuf[d],cols,(size_t)(sizeof(execbuf)-1-d));
         execbuf[sizeof(execbuf)-1]=0;
         d=strlen(execbuf);
         c++;
      }
      else if(data[c]=='%' && data[c+1]!=0)
      {
         c++;
         execbuf[d++]=data[c];
      }
      else execbuf[d++]=data[c];
   }
   execbuf[d]=0;

   system(execbuf);
}

void kom_listflags(char *arg, char *data)
{
   long c;
   char *on;

   linesonscreen=0;
   brk=FALSE;

   for(c=0;flags[c].name && !brk;c++)
   {
      if(flags[c].set) on=strings[STR_FLAGON];
      else             on=strings[STR_FLAGOFF];

      ownprintf("%-50s %s\n",*(flags[c].name),on);
   }

   if(brk)
      printf(strings[STR_BREAK]);
}

void kom_flagon(char *arg,char *data)
{
   struct flag *flag;

   if(!arg)
   {
      printf(strings[STR_NEEDSARG]);
      return;
   }

   if(!(flag=expandflag(arg)))
      return;

   if(flag->set)
   {
      printf(strings[STR_FLAGALREADYON],*(flag->name));
      return;
   }

   flag->set=TRUE;
   printf(strings[STR_FLAGNOWON],*(flag->name));

   UMSWriteConfigTags(login,UMSTAG_CfgName,flag->umsname,
                            UMSTAG_CfgData,"on",
                            TAG_DONE);
}

void kom_flagoff(char *arg,char *data)
{
   struct flag *flag;

   if(!arg)
   {
      printf(strings[STR_NEEDSARG]);
      return;
   }

   if(!(flag=expandflag(arg)))
      return;

   if(!flag->set)
   {
      printf(strings[STR_FLAGALREADYOFF],*(flag->name));
      return;
   }

   flag->set=FALSE;
   printf(strings[STR_FLAGNOWOFF],*(flag->name));

   UMSWriteConfigTags(login,UMSTAG_CfgName,flag->umsname,
                            UMSTAG_CfgData,"off",
                            TAG_DONE);
}

void kom_subscribe(char *arg,char *data)
{
   if(!arg)
   {
      printf(strings[STR_NEEDSARG]);
      return;
   }

   if(stricmp(arg,strings[STR_SUBUNSUBALL])==0)
   {
      struct group *group;
      long c;

      c=0;

      brk=FALSE;
      linesonscreen=0;

      for(group=firstgroup;group && !brk;group=group->next)
         if(group->access && !group->subscribed)
         {
            dosubscribe(group);
            c++;
         }

         if(brk)
         {
            printf(strings[STR_BREAK]);
            return;
         }

      if(c==0)
         printf(strings[STR_SUBALREADYALL]);
   }
   else
   {
      struct group *group;

      if(!(group=expandgroup(arg)))
         return;

      if(group->subscribed)
      {
         printf(strings[STR_SUBALREADY],group->komname);
         return;
      }

      dosubscribe(group);
   }
}

void kom_unsubscribe(char *arg,char *data)
{
   if(!arg)
   {
      printf(strings[STR_NEEDSARG]);
      return;
   }

   if(stricmp(arg,strings[STR_SUBUNSUBALL])==0)
   {
      struct group *group;
      long c;

      c=0;

      brk=FALSE;
      linesonscreen=0;

      for(group=firstgroup;group && !brk;group=group->next)
         if(group->access && group->subscribed && group->umsgroup[0]!=0)
         {
            dounsubscribe(group);
            c++;
         }

         if(brk)
         {
            printf(strings[STR_BREAK]);
            return;
         }

      if(c==0)
         printf(strings[STR_UNSUBALREADYNONE]);
   }
   else
   {
      struct group *group;

      if(!(group=expandgroup(arg)))
         return;

      if(!group->subscribed)
      {
         printf(strings[STR_UNSUBALREADY],group->komname);
         return;
      }

      if(group->umsgroup[0]==0)
      {
         printf(strings[STR_UNSUBNOMAILBOX]);
         return;
      }

      dounsubscribe(group);
   }
}

void kom_park(char *arg,char *data)
{
   long num,res,globalflags;

   if(!getargorlast(arg,&num))
      return;

   res=UMSReadMsgTags(login,UMSTAG_RMsgNum,       num,
                            UMSTAG_RGlobalFlags,  &globalflags,
                            TAG_END);

   if(!res)
   {
      printf(strings[STR_TEXTNRNOTEXIST],num);
      return;
   }

   if(globalflags & UMSGSTATF_Parked)
   {
      printf(strings[STR_ALREADYPARKED],num);
      return;
   }

   res=UMSSelectTags(login,UMSTAG_SelMsg,        num,
                           UMSTAG_SelWriteGlobal,TRUE,
                           UMSTAG_SelSet,        UMSGSTATF_Parked,
                           TAG_DONE);

   if(res)
      printf(strings[STR_PARKOK],num);

   else
      printf(strings[STR_PARKFAIL],num,UMSErrTxt(login));
}

void kom_unpark(char *arg,char *data)
{
   long num,res,globalflags;

   if(!getargorlast(arg,&num))
      return;

   res=UMSReadMsgTags(login,UMSTAG_RMsgNum,       num,
                            UMSTAG_RGlobalFlags,  &globalflags,
                            TAG_END);

   if(!res)
   {
      printf(strings[STR_TEXTNRNOTEXIST],num);
      return;
   }

   if(!(globalflags & UMSGSTATF_Parked))
   {
      printf(strings[STR_NOTPARKED],num);
      return;
   }

   res=UMSSelectTags(login,UMSTAG_SelMsg,        num,
                           UMSTAG_SelWriteGlobal,TRUE,
                           UMSTAG_SelUnset,      UMSGSTATF_Parked,
                           TAG_DONE);

   if(res)
      printf(strings[STR_UNPARKOK],num);

   else
      printf(strings[STR_UNPARKFAIL],num,UMSErrTxt(login));
}

void kom_listselected(char *arg,char *data)
{
   long lastnum,res,chainup,userflags;
   char *fromname,*subject,ast;

   linesonscreen=0;
   lastnum=0;
   brk=FALSE;

   ownprintf("  %-7.7s %-30.30s %.*s\n\n",
      strings[STR_LISTNR],
      strings[STR_LISTFROM],
      currentwidth-2-7-1-30-1,
      strings[STR_LISTSUBJECT]);

   while(!brk)
   {
      lastnum=UMSSearchTags(login,UMSTAG_SearchLocal, TRUE,
                                  UMSTAG_SearchLast,  lastnum,
                                  UMSTAG_SearchMask,  UMSFLAG_MATCHSEARCH,
                                  UMSTAG_SearchMatch, UMSFLAG_MATCHSEARCH,
                                  TAG_DONE);

      if(!lastnum)
         return;

      res=UMSReadMsgTags(login,UMSTAG_RMsgNum,       lastnum,
                               UMSTAG_RFromName,     &fromname,
                               UMSTAG_RSubject,      &subject,
                               UMSTAG_RChainUp,      &chainup,
                               TAG_DONE);

      if(!subject) subject="";

      if(res)
      {
         ast=' ';

         if(chainup)
            if(UMSReadMsgTags(login,UMSTAG_RMsgNum,chainup,UMSTAG_RUserFlags,&userflags,TAG_DONE))
            {
               if(userflags & UMSUSTATF_Owner) ast='*';
               UMSFreeMsg(login,chainup);
            }

         ownprintf("%c %-7ld %-30.30s %.*s\n",
            ast,
            lastnum,
            fromname,
            currentwidth-2-7-1-30-1,
            subject);

         UMSFreeMsg(login,lastnum);
      }
      else
      {
         ownprintf("%-7ld %s\n",lastnum,strings[STR_TEXTNOTEXIST]);
      }
   }

   printf(strings[STR_BREAK]);
}