regina/rxqueue.c

   1 /*
   2  *  The Regina Rexx Interpreter
   3  *  Copyright (C) 1992-1994  Anders Christensen <anders@pvv.unit.no>
   4  *
   5  *  This library is free software; you can redistribute it and/or
   6  *  modify it under the terms of the GNU Library General Public
   7  *  License as published by the Free Software Foundation; either
   8  *  version 2 of the License, or (at your option) any later version.
   9  *
  10  *  This library is distributed in the hope that it will be useful,
  11  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
  12  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  13  *  Library General Public License for more details.
  14  *
  15  *  You should have received a copy of the GNU Library General Public
  16  *  License along with this library; if not, write to the Free
  17  *  Software Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
  18  */
  19
  20 #define NO_CTYPE_REPLACEMENT
  21 #include "rexx.h"
  22
  23 #ifdef HAVE_CONFIG_H
  24 # include "config.h"
  25 #else
  26 # include "configur.h"
  27 #endif
  28
  29 #ifdef WIN32
  30 # if defined(_MSC_VER)
  31 #  if _MSC_VER >= 1100
  32 /* Stupid MSC can't compile own headers without warning at least in VC 5.0 */
  33 #   pragma warning(disable: 4115 4201 4214 4514)
  34 #  endif
  35 #  include <windows.h>
  36 #  if _MSC_VER >= 1100
  37 #   pragma warning(default: 4115 4201 4214)
  38 #  endif
  39 # else
  40 #  include <windows.h>
  41 # endif
  42 # include <io.h>
  43 #else
  44 # ifdef HAVE_SYS_SOCKET_H
  45 #  include <sys/socket.h>
  46 # endif
  47 # ifdef HAVE_NETINET_IN_H
  48 #  include <netinet/in.h>
  49 #  endif
  50 # ifdef HAVE_SYS_SELECT_H
  51 #  include <sys/select.h>
  52 # endif
  53 # ifdef HAVE_NETDB_H
  54 #  include <netdb.h>
  55 # endif
  56 # ifdef HAVE_ARPA_INET_H
  57 #  include <arpa/inet.h>
  58 # endif
  59 #endif
  60
  61 #ifdef __LCC__
  62 # include <winsock2.h>
  63 #endif
  64
  65 #include <string.h>
  66
  67 #ifdef HAVE_UNISTD_H
  68 #include <unistd.h>
  69 #endif
  70
  71 #ifdef HAVE_ERRNO_H
  72 #include <errno.h>
  73 #endif
  74
  75 #ifdef HAVE_SIGNAL_H
  76 #include <signal.h>
  77 #endif
  78
  79 #ifdef HAVE_CTYPE_H
  80 #include <ctype.h>
  81 #endif
  82
  83 #include "extstack.h"
  84
  85 #define SUCCESS(a) ((a)&&(a)->value[0] == '0')
  86
  87 /*
  88  * debugging is turned off. You can turn it on by the command line option "-D".
  89  */
  90 static int debug = 0 ;
  91 #define DEBUGDUMP(x) { if ( debug ) \
  92                           {x;}      \
  93                      }
  94
  95 char *buff=NULL;
  96 unsigned int bufflen=0;
  97
  98 #if !defined(HAVE_STRERROR)
  99 /*
 100  * Sigh! This must probably be done this way, although it's incredibly
 101  * backwards. Some versions of gcc comes with a complete set of ANSI C
 102  * include files, which contains the definition of strerror(). However,
 103  * that function does not exist in the default libraries of SunOS.
 104  * To circumvent that problem, strerror() is #define'd to get_sys_errlist()
 105  * in config.h, and here follows the definition of that function.
 106  * Originally, strerror() was #defined to sys_errlist[x], but that does
 107  * not work if string.h contains a declaration of the (non-existing)
 108  * function strerror().
 109  *
 110  * So, this is a mismatch between the include files and the library, and
 111  * it should not create problems for Regina. However, the _user_ will not
 112  * encounter any problems until he compiles Regina, so we'll have to
 113  * clean up after a buggy installation of the C compiler!
 114  */
 115 const char *get_sys_errlist( int num )
 116 {
 117    extern char *sys_errlist[] ;
 118    return sys_errlist[num] ;
 119 }
 120 #endif
 121
 122 streng *Str_upper( streng *str )
 123 {
 124    int i;
 125
 126    for ( i = 0; i < PSTRENGLEN( str ); i++ )
 127    {
 128       if ( islower( str->value[i] ) )
 129          str->value[i] = (char)toupper( str->value[i] );
 130    }
 131    return str;
 132 }
 133
 134 int send_all( int sock, char *action )
 135 {
 136    /*
 137     * Send everything in stdin to the socket. Each LF encountered
 138     * results in a send.
 139     * This code borrowed from rxstack.c in REXX/imc
 140     */
 141    int c,rc;
 142    unsigned int len;
 143    streng *result;
 144
 145    for ( ; ; )
 146    {
 147       len = 0;
 148       while ( ( c = getchar() ) != EOF )
 149       {
 150          if ( c == REGINA_EOL )
 151          {
 152 #if defined(DOS) || defined(OS2) || defined(WIN32)
 153             if (len && ( buff[len-1] == REGINA_CR ) )
 154                len--;
 155 #endif
 156             break;
 157          }
 158          if ( len >= bufflen
 159          && (( buff = (char *)realloc( buff, bufflen <<= 1 ) ) == NULL ) )
 160          {
 161            showerror( ERR_STORAGE_EXHAUSTED, 0, ERR_STORAGE_EXHAUSTED_TMPL );
 162            exit( ERR_STORAGE_EXHAUSTED );
 163          }
 164          buff[len++] = (char)c;
 165       }
 166       if ( (c == EOF || feof(stdin) )
 167       &&  !len)
 168          break;
 169       DEBUGDUMP(printf("--- Queue %s ---\n", action[0] == RXSTACK_QUEUE_FIFO ? "FIFO" : "LIFO"););
 170       rc = send_command_to_rxstack( NULL, sock, action, buff, len );
 171       if ( rc != -1 )
 172       {
 173          result = read_result_from_rxstack( NULL, sock, RXSTACK_HEADER_SIZE );
 174          DROPSTRENG( result );
 175       }
 176    }
 177    return 0;
 178 }
 179
 180 char *get_unspecified_queue( void )
 181 {
 182    char *rxq = getenv( "RXQUEUE" );
 183
 184    if ( rxq == NULL )
 185       rxq = "SESSION";
 186    return rxq;
 187 }
 188
 189 char *force_remote( char *rxq )
 190 {
 191    char *h ;
 192
 193    if ( strchr(rxq, '@' ) == NULL )
 194    {
 195       if ( ( h = (char *)malloc( strlen( rxq ) + 2 ) ) != NULL )
 196       {
 197          strcpy( h, rxq ) ;
 198          strcat( h, "@" ) ;
 199          return h ;
 200       }
 201    }
 202    return rxq ;
 203 }
 204
 205 char *get_action( char *parm )
 206 {
 207    char *action=NULL;
 208
 209    if ( strcmp( parm, "/fifo" ) == 0 )
 210       action = RXSTACK_QUEUE_FIFO_STR;
 211    else if ( strcmp( parm, "/lifo" ) == 0 )
 212       action = RXSTACK_QUEUE_LIFO_STR;
 213    else if ( strcmp( parm, "/clear" ) == 0 )
 214       action = RXSTACK_EMPTY_QUEUE_STR;
 215    else if ( strcmp( parm, "/pull" ) == 0 )
 216       action = RXSTACK_PULL_STR;
 217    else if ( strcmp( parm, "/queued" ) == 0 )
 218       action = RXSTACK_NUMBER_IN_QUEUE_STR;
 219    else
 220    {
 221       showerror( ERR_EXTERNAL_QUEUE, ERR_RXSTACK_INVALID_SWITCH, ERR_RXSTACK_INVALID_SWITCH_TMPL, "/fifo, /lifo, /clear, /queued, /pull" );
 222       /* not setting action will exit */
 223    }
 224    return action;
 225 }
 226
 227 void junk_return_from_rxstack( int sock, streng *header )
 228 {
 229    int length;
 230    streng *result;
 231
 232    length = get_length_from_header( NULL, header );
 233    if ( length )
 234    {
 235       result = read_result_from_rxstack( NULL, sock, length );
 236       if ( result )
 237          DROPSTRENG( result );
 238
 239    }
 240 }
 241
 242 int cleanup( void )
 243 {
 244 #ifdef WIN32
 245    WSACleanup();
 246 #endif
 247    if ( buff )
 248       free( buff );
 249    return 0;
 250 }
 251
 252 int main( int argc, char *argv[])
 253 {
 254    int sock,rc=0,num;
 255    char *action;
 256    streng *queue=NULL,*server_name=NULL;
 257    char *in_queue=NULL;
 258    streng *result;
 259    Queue q;
 260 #ifdef WIN32
 261    WORD wsver = (WORD)MAKEWORD(1,1);
 262    WSADATA wsaData;
 263 #endif
 264
 265 #ifdef WIN32
 266    if ( WSAStartup( wsver, &wsaData ) != 0 )
 267    {
 268       showerror( ERR_EXTERNAL_QUEUE, ERR_RXSTACK_NO_WINSOCK, ERR_RXSTACK_NO_WINSOCK_TMPL, WSAGetLastError() );
 269       exit(ERR_RXSTACK_NO_WINSOCK);
 270    }
 271 #endif
 272
 273    argv++ ;
 274    argc-- ;
 275
 276    if ( getenv( "RXDEBUG" ) != NULL )
 277       debug = 1 ;
 278
 279    if ( ( argc >= 1 )
 280      && ( ( strcmp( *argv, "-D" ) == 0 ) || ( strcmp( *argv, "/D" ) == 0 ) ) )
 281    {
 282       debug = 1 ;
 283       putenv( "RXDEBUG=1" ) ;
 284       argc-- ;
 285       argv++ ;
 286    }
 287
 288    action = NULL;
 289    /*
 290     * Process the command line
 291     */
 292    if ( argc == 0 )
 293    {
 294       /*
 295        * "rxqueue"
 296        */
 297       action = RXSTACK_QUEUE_FIFO_STR;
 298       in_queue = get_unspecified_queue();
 299    }
 300    else if ( argc == 1 )
 301    {
 302       /*
 303        * "rxqueue queue"
 304        * or
 305        * "rxqueue /switch"
 306        */
 307       if ( argv[0][0] == '/' )
 308       {
 309          /*
 310           * Only parameter is a switch
 311           */
 312          in_queue = get_unspecified_queue();
 313          action = get_action( argv[0] );
 314       }
 315       else
 316       {
 317          /*
 318           * Only parameter is a queue name
 319           */
 320          in_queue = argv[0];
 321          action = RXSTACK_QUEUE_FIFO_STR;
 322       }
 323    }
 324    else if ( argc == 2 )
 325    {
 326       /*
 327        * "rxqueue queue /switch"
 328        */
 329       in_queue = argv[0];
 330       if ( argv[1][0] == '/' )
 331       {
 332          /*
 333           * Parameter is a switch
 334           */
 335          action = get_action( argv[1] );
 336       }
 337    }
 338    else
 339    {
 340       /*
 341        * ERROR
 342        */
 343       fprintf(stderr, "Invalid number of parameters\n");
 344       rc = 1;
 345    }
 346    in_queue = force_remote( in_queue ) ;
 347    if ( action )
 348    {
 349       queue = MAKESTRENG( strlen( in_queue ) );
 350       if ( queue == NULL )
 351       {
 352          showerror( ERR_STORAGE_EXHAUSTED, 0, ERR_STORAGE_EXHAUSTED_TMPL );
 353          exit(ERR_STORAGE_EXHAUSTED);
 354       }
 355       memcpy( PSTRENGVAL( queue ), in_queue, PSTRENGLEN( queue ) );
 356       queue->len = strlen( in_queue ) ;
 357       /*
 358        * Parse the queue to determine server address
 359        * and queue name
 360        */
 361       if ( parse_queue( NULL, queue, &q ) == 1 )
 362       {
 363          if ( PSTRENGLEN( queue ) == 0 )
 364          {
 365             DROPSTRENG( queue );
 366             queue = MAKESTRENG( 7 );
 367             if ( queue == NULL )
 368             {
 369                showerror( ERR_STORAGE_EXHAUSTED, 0, ERR_STORAGE_EXHAUSTED_TMPL );
 370                exit(ERR_STORAGE_EXHAUSTED);
 371             }
 372             memcpy( PSTRENGVAL( queue ), "SESSION", 7 );
 373             queue->len = 7 ;
 374          }
 375          DEBUGDUMP(printf( "queue: <%.*s> server: %.*s<%d> Port:%d\n", PSTRENGLEN( queue ), PSTRENGVAL( queue ), PSTRENGLEN( q.u.e.name ), PSTRENGVAL( q.u.e.name ), q.u.e.address, q.u.e.portno ););
 376          sock = connect_to_rxstack( NULL, &q );
 377          if ( sock < 0 )
 378          {
 379             cleanup();
 380             exit(ERR_RXSTACK_CANT_CONNECT);
 381          }
 382          /*
 383           * Now process the actual command
 384           */
 385          switch( action[0] )
 386          {
 387             case RXSTACK_QUEUE_FIFO:
 388             case RXSTACK_QUEUE_LIFO:
 389                DEBUGDUMP(printf("--- Queue %s ", action[0] == RXSTACK_QUEUE_FIFO ? "FIFO" : "LIFO"););
 390                /*
 391                 * Allocate the initial buffer
 392                 */
 393                if (( buff = (char *)malloc( bufflen = 256 ) ) == NULL )
 394                {
 395                   showerror( ERR_STORAGE_EXHAUSTED, 0, ERR_STORAGE_EXHAUSTED_TMPL );
 396                   rc = ERR_STORAGE_EXHAUSTED;
 397                   break;
 398                }
 399                /*
 400                 * Set the current queue
 401                 */
 402                DEBUGDUMP(printf("(Set Queue) ---\n"););
 403                rc = send_command_to_rxstack( NULL, sock, RXSTACK_SET_QUEUE_STR, PSTRENGVAL( queue) , PSTRENGLEN( queue ) );
 404                if ( rc == -1 )
 405                {
 406                   showerror( ERR_EXTERNAL_QUEUE, ERR_RXSTACK_INTERNAL, ERR_RXSTACK_INTERNAL_TMPL, rc, "Setting default queue" );
 407                   rc = ERR_RXSTACK_INTERNAL;
 408                   break;
 409                }
 410                result = read_result_from_rxstack( NULL, sock, RXSTACK_HEADER_SIZE );
 411                if ( !SUCCESS( result ) )
 412                {
 413                   showerror( ERR_EXTERNAL_QUEUE, ERR_RXSTACK_INTERNAL, ERR_RXSTACK_INTERNAL_TMPL, rc, "Setting default queue" );
 414                   DROPSTRENG( result );
 415                   rc = ERR_RXSTACK_INTERNAL;
 416                   break;
 417                }
 418                /*
 419                 * Success. We need to throw away the returned queue name. We
 420                 * don't need it.
 421                 */
 422                junk_return_from_rxstack( sock, result );
 423                send_all( sock, action );
 424                DROPSTRENG( result );
 425                rc = 0;
 426                break;
 427             case RXSTACK_EMPTY_QUEUE:
 428                DEBUGDUMP(printf("--- Empty Queue ---\n"););
 429                rc = send_command_to_rxstack( NULL, sock, action, PSTRENGVAL( queue) , PSTRENGLEN( queue ) );
 430                if ( rc == -1 )
 431                {
 432                   showerror( ERR_EXTERNAL_QUEUE, ERR_RXSTACK_INTERNAL, ERR_RXSTACK_INTERNAL_TMPL, rc, "Emptying queue" );
 433                   rc = ERR_RXSTACK_INTERNAL;
 434                   break;
 435                }
 436                result = read_result_from_rxstack( NULL, sock, RXSTACK_HEADER_SIZE );
 437                if ( !SUCCESS( result ) )
 438                {
 439                   showerror( ERR_EXTERNAL_QUEUE, ERR_RXSTACK_INTERNAL, ERR_RXSTACK_INTERNAL_TMPL, rc, "Emptying queue" );
 440                   DROPSTRENG( result );
 441                   rc = ERR_RXSTACK_INTERNAL;
 442                   break;
 443                }
 444                DROPSTRENG( result );
 445                rc = 0;
 446                break;
 447             case RXSTACK_NUMBER_IN_QUEUE:
 448                /*
 449                 * Set the current queue
 450                 */
 451                DEBUGDUMP(printf("--- Set Queue ---\n"););
 452                rc = send_command_to_rxstack( NULL, sock, RXSTACK_SET_QUEUE_STR, PSTRENGVAL( queue ), PSTRENGLEN( queue ) );
 453                if ( rc == -1 )
 454                {
 455                   showerror( ERR_EXTERNAL_QUEUE, ERR_RXSTACK_INTERNAL, ERR_RXSTACK_INTERNAL_TMPL, rc, "Setting default queue" );
 456                   rc = ERR_RXSTACK_INTERNAL;
 457                   break;
 458                }
 459                /*
 460                 * Read the return response header
 461                 */
 462                result = read_result_from_rxstack( NULL, sock, RXSTACK_HEADER_SIZE );
 463                if ( !SUCCESS( result ) )
 464                {
 465                   showerror( ERR_EXTERNAL_QUEUE, ERR_RXSTACK_INTERNAL, ERR_RXSTACK_INTERNAL_TMPL, rc, "Setting default queue" );
 466                   DROPSTRENG( result );
 467                   rc = ERR_RXSTACK_INTERNAL;
 468                   break;
 469                }
 470                /*
 471                 * Success. We need to throw away the returned queue name. We
 472                 * don't need it.
 473                 */
 474                junk_return_from_rxstack( sock, result );
 475                DROPSTRENG( result );
 476                DEBUGDUMP(printf("--- Number in Queue ---\n"););
 477                num = get_number_in_queue_from_rxstack( NULL, sock, &rc );
 478                if ( rc == 0 )
 479                   printf("%d\n", num );
 480                break;
 481             case RXSTACK_PULL:
 482                /*
 483                 * Set the current queue
 484                 */
 485                DEBUGDUMP(printf("--- Set Queue ---\n"););
 486                rc = send_command_to_rxstack( NULL, sock, RXSTACK_SET_QUEUE_STR, PSTRENGVAL( queue ), PSTRENGLEN( queue ) );
 487                if ( rc == -1 )
 488                {
 489                   showerror( ERR_EXTERNAL_QUEUE, ERR_RXSTACK_INTERNAL, ERR_RXSTACK_INTERNAL_TMPL, rc, "Setting default queue" );
 490                   rc = ERR_RXSTACK_INTERNAL;
 491                   break;
 492                }
 493                result = read_result_from_rxstack( NULL, sock, RXSTACK_HEADER_SIZE );
 494                if ( !SUCCESS( result ) )
 495                {
 496                   showerror( ERR_EXTERNAL_QUEUE, ERR_RXSTACK_INTERNAL, ERR_RXSTACK_INTERNAL_TMPL, rc, "Setting default queue" );
 497                   DROPSTRENG( result );
 498                   rc = ERR_RXSTACK_INTERNAL;
 499                   break;
 500                }
 501                /*
 502                 * Success. We need to throw away the returned queue name. We
 503                 * don't need it.
 504                 */
 505                junk_return_from_rxstack( sock, result );
 506                DROPSTRENG( result );
 507                /*
 508                 * Loop until the number of lines on the queue is zero
 509                 */
 510                for ( ; ; )
 511                {
 512                   DEBUGDUMP(printf("--- Pull ---\n"););
 513                   rc = get_line_from_rxstack( NULL, sock, &result, 0 );
 514                   if ( rc == 0 )
 515                   {
 516                      printf( "%.*s\n", PSTRENGLEN( result ), PSTRENGVAL( result ) ) ;
 517                   }
 518                   else if ( ( rc == 1 ) || ( rc == 4 ) )
 519                   {
 520                      /*
 521                       * Queue empty.
 522                       */
 523                      rc = 0;
 524                      break;
 525                   }
 526                   else
 527                   {
 528                      showerror( ERR_EXTERNAL_QUEUE, ERR_RXSTACK_INTERNAL, ERR_RXSTACK_INTERNAL_TMPL, rc, "Getting line from queue" );
 529                      rc = ERR_RXSTACK_INTERNAL;
 530                      break;
 531                   }
 532                   DROPSTRENG( result );
 533                }
 534                break;
 535          }
 536          /*
 537           * Tell the server we want to disconnect
 538           * Don't expect any return result.
 539           */
 540          DEBUGDUMP(printf("--- Exit ---\n"););
 541          send_command_to_rxstack( NULL, sock, RXSTACK_EXIT_STR, NULL, 0 );
 542          close(sock);
 543       }
 544       else
 545       {
 546          DEBUGDUMP(printf( "queue: <%.*s>\n", PSTRENGLEN( queue ), PSTRENGVAL( queue ) ););
 547          rc = 1;
 548       }
 549    }
 550    DROPSTRENG( server_name );
 551    DROPSTRENG( queue );
 552    cleanup();
 553    return rc;
 554 }