usr/src/lib/libshell/common/bltins/mkservice.c

   1 /***********************************************************************
   2 *                                                                      *
   3 *               This software is part of the ast package               *
   4 *          Copyright (c) 1982-2010 AT&T Intellectual Property          *
   5 *                      and is licensed under the                       *
   6 *                  Common Public License, Version 1.0                  *
   7 *                    by AT&T Intellectual Property                     *
   8 *                                                                      *
   9 *                A copy of the License is available at                 *
  10 *            http://www.opensource.org/licenses/cpl1.0.txt             *
  11 *         (with md5 checksum 059e8cd6165cb4c31e351f2b69388fd9)         *
  12 *                                                                      *
  13 *              Information and Software Systems Research               *
  14 *                            AT&T Research                             *
  15 *                           Florham Park NJ                            *
  16 *                                                                      *
  17 *                  David Korn <dgk@research.att.com>                   *
  18 *                                                                      *
  19 ***********************************************************************/
  20 #pragma prototyped
  21 /*
  22  * mkservice varname pathname
  23  * eloop [-t timeout]
  24  * Written by David Korn
  25  * AT&T Labs
  26  */
  27
  28 static const char mkservice_usage[] =
  29 "[-?\n@(#)$Id: mkservice (AT&T Research) 2001-06-13 $\n]"
  30 USAGE_LICENSE
  31 "[+NAME? mkservice - create a shell server ]"
  32 "[+DESCRIPTION?\bmkservice\b creates a tcp or udp server that is "
  33         "implemented by shell functions.]"
  34 "[+?The \aservice_path\a must be of the form \b/dev/tcp/localhost/\b\aportno\a "
  35         "or \b/dev/udp/localhost/\b\aportno\a depending on whether the "
  36         "\btcp\b or \budp\b protocol is used.  \aportno\a is the port "
  37         "number that the service will use.]"
  38 "[+?The shell variable \avarname\a is associated with the service.  This "
  39         "variable can have subvariables that keeps the state of all "
  40         "active connections.  The functions \avarname\a\b.accept\b, "
  41         "\avarname\a\b.action\b and \avarname\a\b.close\b implement the "
  42         "service as follows:]{"
  43         "[+accept?This function is invoked when a client tries to connect "
  44                 "to the service.  It is called with an argument which "
  45                 "is the file descriptor number associated with the "
  46                 "accepted connection.  If the function returns a non-zero "
  47                 "value, this connection will be closed.]"
  48         "[+action?This function is invoked when there is data waiting "
  49                 "to be read from one of the active connections.  It is "
  50                 "called with the file descriptor number that has data "
  51                 "to be read.  If the function returns a non-zero "
  52                 "value, this connection will be closed.]"
  53         "[+close?This function is invoked when the connection is closed.]"
  54         "}"
  55 "[+?If \avarname\a is unset, then all active connection, and the service "
  56         "itself will be closed.]"
  57 ""
  58 "\n"
  59 "\nvarname service_path\n"
  60 "\n"
  61 "[+EXIT STATUS?]{"
  62         "[+0?Success.]"
  63         "[+>0?An error occurred.]"
  64 "}"
  65 "[+SEE ALSO?\beloop\b(1)]"
  66 ;
  67
  68
  69 static const char eloop_usage[] =
  70 "[-?\n@(#)$Id: eloop (AT&T Research) 2001-06-13 $\n]"
  71 USAGE_LICENSE
  72 "[+NAME? eloop - process event loop]"
  73 "[+DESCRIPTION?\beloop\b causes the shell to block waiting for events "
  74         "to process.  By default, \beloop\b does not return.]"
  75 "[t]#[timeout?\atimeout\a is the number of milliseconds to wait "
  76         "without receiving any events to process.]"
  77 "\n"
  78 "\n\n"
  79 "\n"
  80 "[+EXIT STATUS?If no timeout is specified, \beloop\b will not return "
  81         "unless interrupted.  Otherwise]{"
  82         "[+0?The specified timeout interval occurred.]"
  83         "[+>0?An error occurred.]"
  84 "}"
  85 "[+SEE ALSO?\bmkservice\b(1)]"
  86 ;
  87
  88
  89 #include        "defs.h"
  90
  91 #include        <cmd.h>
  92 #include        <error.h>
  93 #include        <nval.h>
  94 #include        <sys/socket.h>
  95 #include        <netinet/in.h>
  96
  97 #define ACCEPT  0
  98 #define ACTION  1
  99 #define CLOSE   2
 100
 101 #ifndef O_SERVICE
 102 #   define O_SERVICE    O_NOCTTY
 103 #endif
 104
 105 static const char*      disctab[] =
 106 {
 107         "accept",
 108         "action",
 109         "close",
 110         0
 111 };
 112
 113 typedef struct Service_s Service_t;
 114
 115 struct Service_s
 116 {
 117         Namfun_t        fun;
 118         short           fd;
 119         int             refcount;
 120         int             (*acceptf)(Service_t*,int);
 121         int             (*actionf)(Service_t*,int,int);
 122         int             (*errorf)(Service_t*,int,const char*, ...);
 123         void            *context;
 124         Namval_t*       node;
 125         Namval_t*       disc[elementsof(disctab)-1];
 126 };
 127
 128 static short            *file_list;
 129 static Sfio_t           **poll_list;
 130 static Service_t        **service_list;
 131 static int              npoll;
 132 static int              nready;
 133 static int              ready;
 134 static int              (*covered_fdnotify)(int, int);
 135
 136 static int fdclose(Service_t *sp, register int fd)
 137 {
 138         register int i;
 139         service_list[fd] = 0;
 140         if(sp->fd==fd)
 141                 sp->fd = -1;
 142         for(i=0; i < npoll; i++)
 143         {
 144                 if(file_list[i]==fd)
 145                 {
 146                         file_list[i] = file_list[npoll--];
 147                         if(sp->actionf)
 148                                 (*sp->actionf)(sp, fd, 1);
 149                         return(1);
 150                 }
 151         }
 152         return(0);
 153 }
 154
 155 static int fdnotify(int fd1, int fd2)
 156 {
 157         Service_t *sp;
 158         if (covered_fdnotify)
 159                 (*covered_fdnotify)(fd1, fd2);
 160         if(fd2!=SH_FDCLOSE)
 161         {
 162                 register int i;
 163                 service_list[fd2] = service_list[fd1];
 164                 service_list[fd1] = 0;
 165                 for(i=0; i < npoll; i++)
 166                 {
 167                         if(file_list[i]==fd1)
 168                         {
 169                                 file_list[i] = fd2;
 170                                 return(0);
 171                         }
 172                 }
 173         }
 174         else if(sp = service_list[fd1])
 175         {
 176                 fdclose(sp,fd1);
 177                 if(--sp->refcount==0)
 178                         nv_unset(sp->node);
 179         }
 180         return(0);
 181 }
 182
 183 static void process_stream(Sfio_t* iop)
 184 {
 185         int r=0, fd = sffileno(iop);
 186         Service_t * sp = service_list[fd];
 187         if(fd==sp->fd)  /* connection socket */
 188         {
 189                 struct sockaddr addr;
 190                 socklen_t addrlen = sizeof(addr);
 191                 fd = accept(fd, &addr, &addrlen);
 192                 service_list[fd] = sp;
 193                 sp->refcount++;
 194                 file_list[npoll++] = fd;
 195                 if(fd>=0)
 196                 {
 197                         if(sp->acceptf)
 198                                 r = (*sp->acceptf)(sp,fd);
 199                 }
 200         }
 201         else if(sp->actionf)
 202         {
 203                 service_list[fd] = 0;
 204                 r = (*sp->actionf)(sp, fd, 0);
 205                 service_list[fd] = sp;
 206                 if(r<0)
 207                         close(fd);
 208         }
 209 }
 210
 211 static int waitnotify(int fd, long timeout, int rw)
 212 {
 213         Sfio_t *special=0, **pstream;
 214         register int    i;
 215
 216         if (fd >= 0)
 217                 special = sh_fd2sfio(fd);
 218         while(1)
 219         {
 220                 pstream = poll_list;
 221                 while(ready < nready)
 222                         process_stream(pstream[ready++]);
 223                 if(special)
 224                         *pstream++ = special;
 225                 for(i=0; i < npoll; i++)
 226                 {
 227                         if(service_list[file_list[i]])
 228                                 *pstream++ = sh_fd2sfio(file_list[i]);
 229                 }
 230 #if 1
 231                 for(i=0; i < pstream-poll_list; i++)
 232                         sfset(poll_list[i],SF_WRITE,0);
 233 #endif
 234                 nready = ready = 0;
 235                 errno = 0;
 236 #ifdef DEBUG
 237                 sfprintf(sfstderr,"before poll npoll=%d",pstream-poll_list);
 238                 for(i=0; i < pstream-poll_list; i++)
 239                         sfprintf(sfstderr," %d",sffileno(poll_list[i]));
 240                 sfputc(sfstderr,'\n');
 241 #endif
 242                 nready  = sfpoll(poll_list,pstream-poll_list,timeout);
 243 #ifdef DEBUG
 244                 sfprintf(sfstderr,"after poll nready=%d",nready);
 245                 for(i=0; i < nready; i++)
 246                         sfprintf(sfstderr," %d",sffileno(poll_list[i]));
 247                 sfputc(sfstderr,'\n');
 248 #endif
 249 #if 1
 250                 for(i=0; i < pstream-poll_list; i++)
 251                         sfset(poll_list[i],SF_WRITE,1);
 252 #endif
 253                 if(nready<=0)
 254                         return(errno? -1: 0);
 255                 if(special && poll_list[0]==special)
 256                 {
 257                         ready = 1;
 258                         return(fd);
 259                 }
 260         }
 261 }
 262
 263 static int service_init(void)
 264 {
 265         file_list =  newof(NULL,short,n,0);
 266         poll_list =  newof(NULL,Sfio_t*,n,0);
 267         service_list =  newof(NULL,Service_t*,n,0);
 268         covered_fdnotify = sh_fdnotify(fdnotify);
 269         sh_waitnotify(waitnotify);
 270         return(1);
 271 }
 272
 273 void service_add(Service_t *sp)
 274 {
 275         static int init;
 276         if (!init)
 277                 init = service_init();
 278         service_list[sp->fd] = sp;
 279         file_list[npoll++] = sp->fd;
 280 }
 281
 282 static int Accept(register Service_t *sp, int accept_fd)
 283 {
 284         register Namval_t*      nq = sp->disc[ACCEPT];
 285         int                     fd;
 286
 287         fd = fcntl(accept_fd, F_DUPFD, 10);
 288         if (fd >= 0)
 289         {
 290                 close(accept_fd);
 291                 if (nq)
 292                 {
 293                         char*   av[3];
 294                         char    buff[20];
 295
 296                         av[1] = buff;
 297                         av[2] = 0;
 298                         sfsprintf(buff, sizeof(buff), "%d", fd);
 299                         if (sh_fun(nq, sp->node, av))
 300                         {
 301                                 close(fd);
 302                                 return -1;
 303                         }
 304                 }
 305         }
 306         sfsync(NiL);
 307         return fd;
 308 }
 309
 310 static int Action(Service_t *sp, int fd, int close)
 311 {
 312         register Namval_t*      nq;
 313         int                     r=0;
 314
 315         if(close)
 316                 nq = sp->disc[CLOSE];
 317         else
 318                 nq = sp->disc[ACTION];
 319         if (nq)
 320         {
 321                 char*   av[3];
 322                 char    buff[20];
 323
 324                 av[1] = buff;
 325                 av[2] = 0;
 326                 sfsprintf(buff, sizeof(buff), "%d", fd);
 327                 r=sh_fun(nq, sp->node, av);
 328         }
 329         sfsync(NiL);
 330         return r > 0 ? -1 : 1;
 331 }
 332
 333 static int Error(Service_t *sp, int level, const char* arg, ...)
 334 {
 335         va_list                 ap;
 336
 337         va_start(ap, arg);
 338         if(sp->node)
 339                 nv_unset(sp->node);
 340         free((void*)sp);
 341         errorv(NiL, ERROR_exit(1), ap);
 342         va_end(ap);
 343         return 0;
 344 }
 345
 346 static char* setdisc(Namval_t* np, const char* event, Namval_t* action, Namfun_t* fp)
 347 {
 348         register Service_t*     sp = (Service_t*)fp;
 349         register const char*    cp;
 350         register int            i;
 351         register int            n = strlen(event) - 1;
 352         register Namval_t*      nq;
 353
 354         for (i = 0; cp = disctab[i]; i++)
 355         {
 356                 if (memcmp(event, cp, n))
 357                         continue;
 358                 if (action == np)
 359                         action = sp->disc[i];
 360                 else
 361                 {
 362                         if (nq = sp->disc[i])
 363                                 free((void*)nq);
 364                         if (action)
 365                                 sp->disc[i] = action;
 366                         else
 367                                 sp->disc[i] = 0;
 368                 }
 369                 return action ? (char*)action : "";
 370         }
 371         /* try the next level */
 372         return nv_setdisc(np, event, action, fp);
 373 }
 374
 375 static void putval(Namval_t* np, const char* val, int flag, Namfun_t* fp)
 376 {
 377         register Service_t* sp = (Service_t*)fp;
 378         if (!val)
 379                 fp = nv_stack(np, NiL);
 380         nv_putv(np, val, flag, fp);
 381         if (!val)
 382         {
 383                 register int i;
 384                 for(i=0; i< sh.lim.open_max; i++)
 385                 {
 386                         if(service_list[i]==sp)
 387                         {
 388                                 close(i);
 389                                 if(--sp->refcount<=0)
 390                                         break;
 391                         }
 392                 }
 393                 free((void*)fp);
 394                 return;
 395         }
 396 }
 397
 398 static const Namdisc_t servdisc =
 399 {
 400         sizeof(Service_t),
 401         putval,
 402         0,
 403         0,
 404         setdisc
 405 };
 406
 407 int     b_mkservice(int argc, char** argv, void* extra)
 408 {
 409         register char*          var;
 410         register char*          path;
 411         register Namval_t*      np;
 412         register Service_t*     sp;
 413         register int            fd;
 414
 415         NOT_USED(argc);
 416         NOT_USED(extra);
 417         for (;;)
 418         {
 419                 switch (optget(argv, mkservice_usage))
 420                 {
 421                 case 0:
 422                         break;
 423                 case ':':
 424                         error(2, opt_info.arg);
 425                         continue;
 426                 case '?':
 427                         error(ERROR_usage(2), opt_info.arg);
 428                         continue;
 429                 }
 430                 break;
 431         }
 432         argv += opt_info.index;
 433         if (error_info.errors || !(var = *argv++) || !(path = *argv++) || *argv)
 434                 error(ERROR_usage(2), optusage(NiL));
 435         if (!(sp = newof(0, Service_t, 1, 0)))
 436                 error(ERROR_exit(1), "out of space");
 437         sp->acceptf = Accept;
 438         sp->actionf = Action;
 439         sp->errorf = Error;
 440         sp->refcount = 1;
 441         sp->context = extra;
 442         sp->node = 0;
 443         sp->fun.disc = &servdisc;
 444         if((fd = sh_open(path, O_SERVICE|O_RDWR))<=0)
 445         {
 446                 free((void*)sp);
 447                 error(ERROR_exit(1), "%s: cannot start service", path);
 448         }
 449         if((sp->fd = fcntl(fd, F_DUPFD, 10))>=10)
 450                 close(fd);
 451         else
 452                 sp->fd = fd;
 453         np = nv_open(var,sh.var_tree,NV_ARRAY|NV_VARNAME|NV_NOASSIGN);
 454         sp->node = np;
 455         nv_putval(np, path, 0);
 456         nv_stack(np, (Namfun_t*)sp);
 457         service_add(sp);
 458         return(0);
 459 }
 460
 461 int     b_eloop(int argc, char** argv, void* extra)
 462 {
 463         register long   timeout = -1;
 464         NOT_USED(argc);
 465         NOT_USED(extra);
 466         for (;;)
 467         {
 468                 switch (optget(argv, eloop_usage))
 469                 {
 470                 case 0:
 471                         break;
 472                 case 't':
 473                         timeout = opt_info.num;
 474                         continue;
 475                 case ':':
 476                         error(2, opt_info.arg);
 477                         continue;
 478                 case '?':
 479                         error(ERROR_usage(2), opt_info.arg);
 480                         continue;
 481                 }
 482                 break;
 483         }
 484         argv += opt_info.index;
 485         if (error_info.errors  || *argv)
 486                 error(ERROR_usage(2), optusage(NiL));
 487         while(1)
 488         {
 489                 if(waitnotify(-1, timeout, 0)==0)
 490                         break;
 491                 sfprintf(sfstderr,"interrupted\n");
 492         }
 493         return(errno != 0);
 494 }