scitest.c

 
/* scitest
 
command line test program for sci
*/
 
#include <stdio.h>
#include <stdlib.h>
#include <stdarg.h>
#include <string.h>
#include <ctype.h>
#include <stdbool.h>
#include <time.h>
 
#include <socan.h>
#include <sci.h>
 
#include <socan_util.h>
 
/* ----------------------------------------------
 * constants
 * ---------------------------------------------- */
 
#define VERSION "1.0"
 
/* ----------------------------------------------
 * types
 * ---------------------------------------------- */
 
typedef enum { T_CHECK=2, T_REMOTE=4, T_LEAVE=8, T_CONSISTENCE=16,
               T_IGNORE_OLD=32
             } testflags;
 
enum options {
          HELP,
              INTERFACE,
          LEAVE,
          REALTIME,
              TRACE,
              ERRPRINTLEVEL,
              LOOP,
              SLEEP,
              QUIET,
          SIZE,
          COUNT,
          CHECK,
          REMOTE,
          CONSISTENCE,
          IGNORE_OLD,
          RWTEST,
              READ,
              READ_NOW,
              QUEUE_READ,
              WRITE,
              WRITE_W,
              WRITE_INHIBIT,
             };
 
enum commands {
               CMD_NOTHING,
           CMD_RWTEST,
               CMD_READ,
               CMD_READ_NOW,
               CMD_QUEUE_READ,
               CMD_WRITE,
               CMD_WRITE_W,
               CMD_WRITE_INHIBIT
              };
 
/* ----------------------------------------------
 * tests
 * ---------------------------------------------- */
 
static void test_simple_rw(int object1, int port1, int object2, int port2,
                   int w_timeout, int r_timeout,
                   int flag)
  {
    sci_Return rc;
    sci_Struc *s_struc;
    sci_Errcode err;
    sci_Object *obj1, *obj2;
    char wbuf[8]= {0,0,0,0,0,0,0,0};
    char rbuf[8]= {0,0,0,0,0,0,0,0};
    int i;
 
    printf("opening sci :\n");
 
    rc= sci_open(&s_struc, "", &err);
    if (rc!=SCI_NOTHING)
      {
        printf("sci_open returned %s, aborting\n",
               sci_str_status(rc));
        return;
      }
    printf("8 bytes will be written, content of these 8 bytes:\n");
    printf("1 2 3 4 5 6 7 8\n");
    printf("set write-mode for object %d, port %d ...",object1, port1);
    printf("(timeout %d)\n", w_timeout);
    rc= sci_init_object(s_struc, &obj1, port1, object1, 8, w_timeout, 
                        SCI_WRITE, NULL);
    if (rc!=SCI_NOTHING)
      {
        printf("sci_init_object returned %s, aborting\n",
               sci_str_status(rc));
        sci_close(&s_struc);
        return;
      }
 
    printf("set read-mode for object %d, port %d ...",object2, port2);
    printf("(timeout %d)\n", r_timeout);
    rc= sci_init_object(s_struc, &obj2, port2, object2, 8, r_timeout, 
                        SCI_READ, NULL);
    if (rc!=SCI_NOTHING)
      {
        printf("sci_init_object returned %s, aborting\n",
               sci_str_status(rc));
        sci_close(&s_struc);
        return;
      }
    for (i=1; i<=8; i++)
      wbuf[i-1]=i;
 
    printf("now writing the data...");
    rc= sci_write(s_struc, obj1, wbuf);
    if (rc!=SCI_NOTHING)
      {
        printf("sci_write returned %s, aborting\n",
               sci_str_status(rc));
        sci_close(&s_struc);
        return;
      }
    /*
    mldelay(100000);
    return;
    */
 
    printf("now reading the data...");
    rc= sci_read(s_struc, obj2, rbuf);
    if (rc!=SCI_NOTHING)
      {
        printf("sci_read returned %s, aborting\n",
               sci_str_status(rc));
        sci_close(&s_struc);
        return;
      }
 
    printf("message-content:\n");
    nice_dump(rbuf,  8, 0);
 
    printf("closing sci...\n");
    sci_close(&s_struc);
  }
 
static void test_read(int object, int port, unsigned int timeout,
                  int loops,
                      double sleep,
                  int quietlevel, bool readnow,
                  int countsize, int flag)
  {
    sci_Return rc;
    sci_Struc *s_struc;
    sci_Errcode err;
    sci_Object *obj;
    char cbuf[8]= {0, 0, 0, 0, 0, 0, 0, 0}; /* counter is at byte 4 ! */
 
    int  mask;
    int  scale, i, l;
    unsigned long c,count= 0;
    char ch;
    bool print_err;
    char *func_name;
    sci_Object_Type objtype;
 
    if (readnow)
      func_name= "sci_read_now";
    else
      func_name= "sci_read";
 
    if (countsize>=sizeof(int))
      mask= 0xFFFFFFFF;
    else
      mask= 0xFFFFFFFF >> ((sizeof(int)-countsize)*8);
    if (sleep!=0)
      {
        printf("sleeping %f seconds...\n", sleep);
        mldelay((long)(sleep*1000+0.5));
      }
    printf("opening sci :\n");
 
    rc= sci_open(&s_struc, "", &err);
    if (rc!=SCI_NOTHING)
      {
        printf("sci_open returned %s, aborting\n",
               sci_str_status(rc));
        return;
      }
 
    printf("defining read-object...\n");
    if (flag & T_REMOTE)
      objtype= SCI_REMOTE_READ;
    else
      objtype= SOCAN_READ;
    rc= sci_init_object(s_struc, &obj, port, object, countsize, timeout, 
                        objtype, NULL);
    if (rc!=SCI_NOTHING)
      {
        printf("sci_init_object returned %s, aborting\n",
               sci_str_status(rc));
        sci_close(&s_struc);
        return;
      }
 
    eval_quietlevel(quietlevel, &scale, &ch, &l);
 
    for(; loops>0; loops--)
      {
        if (readnow)
          rc= sci_read_now(s_struc, obj, cbuf);
        else
          rc= sci_read(s_struc, obj, cbuf);
        if (quietlevel>0)
          { if (scale)
              if ((--l)<=0)
                { l= scale; putchar(ch); fflush(stdout); };
          }
        else
          { printf("received: data:\n");
            nice_dump(cbuf, countsize, 0);
          };
        if (rc!= SCI_NOTHING)
          {
            print_err= true;
            if ((rc==SCI_OLD_DATA) && (flag & T_IGNORE_OLD))
              print_err= false;
            if (print_err)
              { if ((quietlevel>0) && (rc == SCI_LOST))
                  {
                    putchar('L'); fflush(stdout);
                  }
                else
                  {
                    if (!(rc & SCI_ERROR))
                      { /* no error */
                        printf("%s returned %d (%s)\n",
                               func_name, rc, sci_str_status(rc));
                      }
                    else
                      {
                        sci_get_errcode(s_struc, &err);
                        printf("%s returned error %d (%s)\n",
                               func_name, err, sci_str_err(err));
                      }
                  };
              };
          };
        if (flag & T_CHECK)
          {
            if (flag & T_CONSISTENCE)
              {
                c= cbuf[0];
                for (i=1; i<countsize; i++)
                  if (c!= cbuf[i])
                    {
                      printf("INCONSISTENT DATA!\n");
                      printf("received: data:\n");
                      nice_dump(cbuf, countsize, 0);
                      break;
                    };
              }
            else
              {
                c=0;
                memcpy(&c, cbuf, countsize);
                if (c != count)
                  {
                    if ((c>count) || (countsize>1))
                      {
                        if (quietlevel>1)
                          printf("[%lx,%lx]",c,count);
                        else
                          printf("%ld messages missed, got:%ld expected:%ld\n",
                                 c-count, c, count);
                      }
                    else
                      printf("messages repeated, got:%ld, expected:%ld\n",
                             c, count);
                    count=c;
                  };
                count++;
                count&= mask;
              };
          };
      } /* for */
    if (flag & T_LEAVE)
      {
        printf("driver (on request) not closed!\n");
        for(;;) mldelay(60*1000);
      }
 
    printf("closing sci...\n");
    sci_close(&s_struc);
  }
 
static void test_queue_read(int port, unsigned int timeout,
                            int *ids, int id_no,
                        int loops,
                            double sleep,
                        int quietlevel,
                        int countsize, int flag)
  {
    sci_Return rc;
    sci_Struc *s_struc;
    sci_Errcode err;
    sci_Object **objs;
    sci_Object *obj;
    char cbuf[8]= {0, 0, 0, 0, 0, 0, 0, 0}; /* counter is at byte 4 ! */
 
    int  mask;
    int  scale, i, l;
    unsigned long c;
    char ch;
    bool print_err;
    unsigned long *count= NULL;
    int *indices= NULL;
    int *index;
 
    if (id_no <=0)
      {
        printf("wrong id_no: %d\n", id_no);
        return;
      }
    count= calloc(COB_NO, sizeof(unsigned long));
    indices= calloc(COB_NO, sizeof(int));
    objs= calloc(COB_NO, sizeof(sci_Object *));
 
    if (countsize>=sizeof(int))
      mask= 0xFFFFFFFF;
    else
      mask= 0xFFFFFFFF >> ((sizeof(int)-countsize)*8);
 
    if (sleep!=0)
      {
        printf("sleeping %f seconds...\n", sleep);
        mldelay((long)(sleep*1000+0.5));
      }
    printf("opening sci :\n");
 
    rc= sci_open(&s_struc, "", &err);
    if (rc!=SCI_NOTHING)
      {
        printf("sci_open returned %s, aborting\n",
               sci_str_status(rc));
        return;
      }
 
    printf("defining read-objects...\n");
 
    for(i=0; i<id_no; i++)
      {
        indices[i]= i;
        /* for now, no support for RTR objects here: */
        rc= sci_init_object(s_struc, &(objs[i]), port, ids[i],
                            countsize, timeout, 
                            SCI_READ, &(indices[i]));
        if (rc!=SCI_NOTHING)
          {
            printf("sci_init_object returned %s, aborting\n",
                   sci_str_status(rc));
            sci_close(&s_struc);
            return;
          }
        rc= sci_set_callback(s_struc, objs[i], NULL);
        if (rc!=SCI_NOTHING)
          {
            printf("sci_set_callback returned %s, aborting\n",
                   sci_str_status(rc));
            sci_close(&s_struc);
            return;
          }
      }
 
    eval_quietlevel(quietlevel, &scale, &ch, &l);
 
    for(; loops>0; loops--)
      {
        rc= sci_queue_read(s_struc, &obj, cbuf);
        if (!(rc & SCI_ERROR))
          index= sci_get_user(obj);
        if (quietlevel>0)
          { if (scale)
              if ((--l)<=0)
                { l= scale; putchar(ch); fflush(stdout); };
          }
        else
          { printf("received on %d: data:\n", ids[*index]);
            nice_dump(cbuf, countsize, 0);
          };
        if (rc!= SCI_NOTHING)
          {
            print_err= true;
            if ((rc==SCI_OLD_DATA) && (flag & T_IGNORE_OLD))
              print_err= false;
            if (print_err)
              { if ((quietlevel>0) && (rc == SCI_LOST))
                  {
                    putchar('L'); fflush(stdout);
                  }
                else
                  {
                    if (!(rc & SCI_ERROR))
                      { /* no error */
                        printf("sci_queue_read returned %d (%s)\n",
                               rc, sci_str_status(rc));
                      }
                    else
                      {
                        sci_get_errcode(s_struc, &err);
                        printf("sci_queue_read returned error %d (%s)\n",
                               err, sci_str_err(err));
                      }
                  };
              };
          };
        if (flag & T_CHECK)
          {
            if (flag & T_CONSISTENCE)
              {
                c= cbuf[0];
                for (i=1; i<countsize; i++)
                  if (c!= cbuf[i])
                    {
                      printf("INCONSISTENT DATA!\n");
                      printf("received: data:\n");
                      nice_dump(cbuf, countsize, 0);
                      break;
                    };
              }
            else
              {
                c=0;
                memcpy(&c, cbuf, countsize);
                if (c != (count[*index]))
                  {
                    if ((c>(count[*index])) || (countsize>1))
                      {
                        if (quietlevel>1)
                          printf("[%lx,%lx]",c,(count[*index]));
                        else
                          printf("%ld messages missed, got:%ld expected:%ld\n",
                                 c-(count[*index]), c, (count[*index]));
                      }
                    else
                      printf("messages repeated, got:%ld, expected:%ld\n",
                             c, (count[*index]));
                    (count[*index])=c;
                  };
                (count[*index])++;
                (count[*index])&= mask;
              };
          };
      } /* for */
    if (flag & T_LEAVE)
      {
        printf("driver (on request) not closed!\n");
        for(;;) mldelay(60*1000);
      }
 
    printf("closing sci...\n");
    sci_close(&s_struc);
  }
 
/* the usage of the counter is adjusted to a little-endian machine ! */
static void test_write(int object, int port, unsigned int timeout,
                       unsigned long inhibit_tm,
                   int loops,
                       double sleep,
               int quietlevel,
               int write_cmd,
               int countsize, int countstart,
               int flag)
  {
    sci_Return rc;
    sci_Struc *s_struc;
    sci_Errcode err;
    sci_Object *obj;
    char cbuf[8]= {0, 0, 0, 0, 0, 0, 0, 0}; /* counter is at byte 4 ! */
    int i;
    char ch;
    int  scale;
    int l;
    bool timed= (write_cmd==CMD_WRITE_INHIBIT);
    bool busy_wait= (write_cmd==CMD_WRITE_W);
    unsigned long counter;
    unsigned long timeval;
    char *func_name;
    sci_Object_Type objtype;
 
    switch (write_cmd)
      {
        case CMD_WRITE_INHIBIT:
          func_name= "sci_write_inhibit";
          break;
        case CMD_WRITE:
        case CMD_WRITE_W:
          func_name= "sci_write";
          break;
        default:
          printf("internal error line %d\n", __LINE__);
          return;
      }
 
    counter=countstart;
 
    if (sleep!=0)
      {
        printf("sleeping %f seconds...\n", sleep);
        mldelay((long)(sleep*1000+0.5));
      }
    printf("opening sci :\n");
 
    rc= sci_open(&s_struc, "", &err);
    if (rc!=SCI_NOTHING)
      {
        printf("sci_open returned %s, aborting\n",
               sci_str_status(rc));
        return;
      }
 
    printf("defining write-object...\n");
    if (flag & T_REMOTE)
      objtype= SCI_REMOTE_WRITE;
    else
      objtype= SCI_WRITE;
    rc= sci_init_object(s_struc, &obj, port, object, countsize, timeout, 
                        objtype, NULL);
    if (rc!=SCI_NOTHING)
      {
        printf("sci_init_object returned %s, aborting\n",
               sci_str_status(rc));
        sci_close(&s_struc);
        return;
      }
 
    if (timed)
      {
        rc= sci_set_inhibit(s_struc, obj, inhibit_tm);
        if (rc!=SCI_NOTHING)
          {
            printf("scitest.c line %d: sci_set_inhibit returned "
                   "an error: %d (%s)\n", __LINE__, rc, sci_str_status(rc));
            printf("test-abort!\n");
            sci_close(&s_struc);
            return;
          }
      }
 
    eval_quietlevel(quietlevel, &scale, &ch, &l);
 
    for(; loops>0; loops--)
      { if (flag & T_CONSISTENCE)
          {
            unsigned char b= (unsigned char) counter;
            for(i=0; i<countsize; cbuf[i++]= b);
              /* int converted to byte   ^^^^ !*/
          }
        else
          {
            /* native endianess: */
            memcpy(cbuf, &counter, countsize);
          };
        if (quietlevel>0)
          { if (scale)
              if ((--l)<=0)
                { l= scale; putchar(ch); fflush(stdout); };
          }
        else
          { if (flag & T_CONSISTENCE)
              printf("consistency test with byte %lu\n", counter & 0xFF);
            else
              { printf("writing %lu, %d bytes on %d\n",
                       counter, countsize, object);
              };
          };
      w_again:
        switch (write_cmd)
          {
            case CMD_WRITE_INHIBIT:
              timeval= inhibit_tm;  /* reset the inhibit-time parameter*/
              rc= sci_write_inhibit(s_struc, obj, cbuf, &timeval);
              break;
            case CMD_WRITE:
            case CMD_WRITE_W:
              rc= sci_write(s_struc, obj, cbuf);
              break;
            default:
              printf("INTERNAL ERROR AT LINE %d\n", __LINE__);
          }
        if (rc!= SCI_NOTHING)
          {
            if (busy_wait)
              if (rc == SCI_WAIT) /* we have to busy-wait... */
                goto w_again;
 
            if (timed)
              if (rc == SCI_WAIT) /* we have to wait... */
                {
                  micdelay(timeval);
                  goto w_again;
                };
            if (rc & SCI_ERROR)
              {
                sci_get_errcode(s_struc, &err);
                printf("scitest.c line %d: %s returned an error: %d (%s)\n",
                       __LINE__, func_name, err, sci_str_err(err));
              }
            else
              printf("%s return code: %d (%s)\n", func_name, rc, sci_str_status(rc));
          };
        counter++;
      };
    if (quietlevel>0)
      printf("\n");
 
    if (flag & T_LEAVE)
      { printf("driver (on request) not closed!\n");
        for(;;) mldelay(60*1000);
      }
 
    printf("closing sci...\n");
    sci_close(&s_struc);
  }
 
/* ----------------------------------------------
 * main
 * ---------------------------------------------- */
 
void print_help(void)
  {
    printf(" **** scitest %s ****\n", VERSION);
    printf("the sci test program\n"
           "usage:\n"
           "scitest {options}\n"
           "options:\n"
           " **************** Configuration*****************\n"
           " --interface,-i INTERFACE \n"
           "        Use INTERFACE for CAN communication, this option\n"
           "        can be given more than once to use more than one\n"
           "        interface.\n"
           " --realtime READER-PRIORITY WRITER-PRIORITY\n"
           "        Use given realtime priorities for reader and writer\n"
           "        thread.\n"
           " --leave\n"
           "        for all functions that define CAN-objects, hold the\n"
           "        program just before close() is performed. All CAN\n"
           "        objects remain defined. End the program with CRTL-C in\n"
           "        this case\n"
           " --trace,-t LEVEL\n"
           "        set trace level, LEVEL is an integer 0..2 (default 0)\n"
           " --errprintlevel,-E LEVEL\n"
           "        set errprint level, LEVEL is an integer 0..3 (default 1)\n"
          );
    printf(" *************** command options ***************\n"
           " --loop {no of loops}\n"
           "        run read, write, readnow or readmany in loop-mode\n"
           " --sleep {seconds}\n"
           "        sleep a number of seconds before starting the test.\n"
           "        seconds may be a floating point number.\n"
           " --quiet,-q {level}\n"
           "        run read, write, readnow or readmany in quiet-mode\n"
           "        level may be 1 .. 5, meaning that each 10**(level-1)\n"
           "        events print a single character on the screen.\n"
           " --check\n"
           "        check sequence in --read, (must be used together with\n"
           "        --write in another sotest-task\n"
           " --size,-s [bytes]\n"
           "        use [bytes] bytes to transfer and receive data\n"
           " --count [number]\n"
           "        use [number] as initial number to write with -w\n"
           " --consistence\n"
           "        send alternating 8 bytes of 0xFF or 0x00 to test data\n"
           "        consistence\n"
           " --remote \n"
           "        do remote-read or remote-write, implemented for\n"
           "        --write and --read\n"
          );
    printf(" ***************data transmission commands****************\n"
           " --rwtest [object1] [port1] [object2] [port2] "
                    "[write-timeout] [read-timeout]\n"
           "        make a write-object (object1,port1) and a read-object\n"
           "        (object2,port2) with a timeout set for the 2nd object\n"
           "        then write 8 bytes (values 1 to 8) and read the 2nd\n"
           "        object (read immediately) and return the results\n"
           " --write,-w [object] [port] [timeout]\n"
           "        write data (a running counter), non blocking\n"
           " --write-w [object] [port] [timeout]\n"
           "        the same as --write but do silently retry to write\n"
           "        when the driver returns a SOCAN_WAIT status.\n"
           " --writeinhibit [object] [port] [timeout] [inhibit-time]\n"
           "        similar to writelater, but the CAN-object gets a timestamp\n"
           "        when it is transmitted. Inhibit-time is the minumum\n"
           "        time that has to pass before a new object is sent. This\n"
           "        concerns only writeinhibit combined with the loop-command.\n"
           "        In this case only about every [inhibit-time]\n"
           "        microseconds new data will be sent (note that the unit\n"
           "        for this parameter is microseconds, not milliseconds\n"
           " --read,-r [object] [port] [timeout]\n"
           "        read data from an object (blocking).\n"
           " --readnow [object] [port] [timeout]\n"
           "        read data from an object (immediately).\n"
           " --queue-read [port] [timeout] [object] {[object]}\n"
           "        read more than one object via the signal-function in \n"
           "        conjunction with the new queue-read operation\n"
           "        together with --remote, all objects will be remote-read\n"
           "        objects\n"
           "\n");
  }
 
#define MAX_INTERFACES 4
 
int main( int argc, char *argv[])
 
  {
    static option options[]=
      {
    { "-h"             , HELP },
    { "--help"         , HELP },
    { "-i"             , INTERFACE },
    { "--interface"    , INTERFACE },
    { "--loop"         , LOOP},
    { "-t"             , TRACE},
    { "--trace"        , TRACE},
    { "-E"             , ERRPRINTLEVEL},
    { "--errprintlevel", ERRPRINTLEVEL},
    { "--sleep"        , SLEEP},
    { "-q"             , QUIET},
    { "--quiet"        , QUIET},
    { "--check"        , CHECK},
    { "-s"             , SIZE},
    { "--size"         , SIZE},
    { "--count"        , COUNT},
    { "--leave"        , LEAVE},
    { "--realtime"     , REALTIME},
    { "--remote"       , REMOTE},
    { "--consistence"  , CONSISTENCE},
    { "--ignore_old"   , IGNORE_OLD},
    { "--rwtest"       , RWTEST},
    { "-r"             , READ},
    { "--read"         , READ},
    { "--readnow"      , READ_NOW},
    { "--queue-read"   , QUEUE_READ},
    { "-w"             , WRITE},
    { "--write"        , WRITE},
    { "--write-w"      , WRITE_W},
    { "--writeinhibit" , WRITE_INHIBIT},
      };
 
    int opt_no= sizeof(options) / sizeof(option);
    enum commands operation=CMD_NOTHING;
 
    char *interfaces[MAX_INTERFACES];
    int interface_no=0;
    int n[45], i, l, tracelevel= -1, errprintlevel= -1;
    int     flag=0;
    int     loops=1;
    double  sleep= 0;
    int     quietlevel=0;
    int     countsize  =sizeof(int);
    int     countstart=0;
    int     last_valid_n;
    int     rc, opt_index;
    int     rt_prios[]= {-1, -1};
    int     opt;
    char    *st;
 
    if (argc<2)
      my_exit("error, option/command missing\n");
 
    opt_index= 1;
    while(opt_index<argc)
      {
        opt= match(argc, argv, &opt_index, options, opt_no);
    switch (opt)
      { 
            case -1:
                 my_exit("unknown option: %s\n", argv[opt_index]);
            case HELP:
         print_help();
                 return 0;
            case INTERFACE:
                 if (match_st(argc, argv, &opt_index, &st))
                   my_exit("interface name missing!\n");
                 if (interface_no >= MAX_INTERFACES)
                   my_exit("too many interfaces given (more than %d)\n",
                           MAX_INTERFACES);
                 interfaces[interface_no++]= st;
             break;
            case REALTIME:
             for(i=0; i<=1; i++)
                   {
                     rc= match_int(argc, argv, &opt_index, &(rt_prios[i]));
                     if (rc==-1)
                       my_exit("error, argument missing\n");
                     if (rc==-2)
                       my_exit("error, argument is not a number\n");
           };
                 break;
            case SLEEP:
                 rc= match_float(argc, argv, &opt_index, &sleep);
                 if (rc==-1)
                   my_exit("the sleep parameter is missing!\n");
                 if (rc==-2)
                   my_exit("the sleep parameter is is not a number!\n");
                 break;
            case QUIET:
                 rc= match_int(argc, argv, &opt_index, &quietlevel);
                 if (rc==-1)
                   my_exit("the quiet parameter is missing!\n");
                 if (rc==-2)
                   my_exit("the quiet parameter is is not a number!\n");
                 if ((quietlevel<1) || (quietlevel>5))
                   my_exit("only quiet-levels 1 to 5 are allowed\n"
                           "(input was %d)\n", quietlevel);
                 break;
            case SIZE:
                 rc= match_int(argc, argv, &opt_index, &countsize);
                 if (rc==-1)
                   my_exit("the count parameter is missing!\n");
                 if (rc==-2)
                   my_exit("the count parameter is is not a number!\n");
         if ((countsize<1) || (countsize>8))
           my_exit("[bytes]-parameter must be between 1 and 8 !!\n");
                 break;
            case COUNT:
                 rc= match_int(argc, argv, &opt_index, &countstart);
                 if (rc==-1)
                   my_exit("the countstart parameter is missing!\n");
                 if (rc==-2)
                   my_exit("the countstart parameter is is not a number!\n");
         if ((countstart<0))
           my_exit("[count]-parameter must be greater than 0 !!\n");
                 break;
            case LOOP:
                 rc= match_int(argc, argv, &opt_index, &loops);
                 if (rc==-1)
                   my_exit("the loop parameter is missing!\n");
                 if (rc==-2)
                   my_exit("the loop parameter is is not a number!\n");
                 if (loops<1)
                   my_exit("loop-parameter should be greater than zero!\n"
                           "(input was %ld)\n", loops);
                 break;
            case TRACE:
                 rc= match_int(argc, argv, &opt_index, &tracelevel);
                 if (rc==-1)
                   my_exit("the tracelevel parameter is missing!\n");
                 if (rc==-2)
                   my_exit("the tracelevel parameter is is not a number!\n");
                 if (tracelevel<0)
                   my_exit("trace level must be positive\n"
                           "(input was %d)\n", tracelevel);
                 break;
            case ERRPRINTLEVEL:
                 rc= match_int(argc, argv, &opt_index, &errprintlevel);
                 if (rc==-1)
                   my_exit("the errprintlevel parameter is missing!\n");
                 if (rc==-2)
                   my_exit("the errprintlevel parameter is is not a number!\n");
                 if (errprintlevel<0)
                   my_exit("errprintlevel must be positive\n"
                           "(input was %d)\n", errprintlevel);
                 break;
            case LEAVE:
                 flag|= T_LEAVE;
                 break;
            case REMOTE:
                 flag|= T_REMOTE;
                 break;
            case CHECK:
                 flag|= T_CHECK;
                 break;
            case CONSISTENCE:
                 /* implies the check-flag, too */
                 flag|= (T_CONSISTENCE | T_CHECK);
                 /* countsize is changed to 8 !!! */
                 countsize= 8;
                 break;
            case IGNORE_OLD:
                 flag|= T_IGNORE_OLD;
                 break;
            case RWTEST:
             if (operation!=CMD_NOTHING)
                   my_exit("contradicting options\n");
             operation=CMD_RWTEST;
             for(i=0; i<=5; i++)
               {
                     rc= match_int(argc, argv, &opt_index, &(n[i]));
                     if (rc==-1)
                       my_exit("error, argument missing\n");
                     if (rc==-2)
                       my_exit("error, argument is not a number\n");
           };
                 break;
            case READ:
            case READ_NOW:
             if (operation!=CMD_NOTHING)
                   my_exit("contradicting options\n");
                 switch (opt)
                   {
                     case READ:
                       operation=CMD_READ; break;
                     case READ_NOW:
                       operation=CMD_READ_NOW; break;
                   }
             for(i=0; i<=2; i++)
                   {
                     rc= match_int(argc, argv, &opt_index, &(n[i]));
                     if (rc==-1)
                       my_exit("error, argument missing\n");
                     if (rc==-2)
                       my_exit("error, argument is not a number\n");
           };
                 break;
            case QUEUE_READ:
             if (operation!=CMD_NOTHING)
                   my_exit("contradicting options\n");
             operation= CMD_QUEUE_READ;
                 rc=0;
             last_valid_n=-1;
             while ((rc==0) && (last_valid_n<21))
               {
                     last_valid_n++;
                     rc= match_int(argc, argv, &opt_index, &(n[last_valid_n]));
                     switch(last_valid_n)
                       {
                         case 0:
                           if (rc!=0)
                             my_exit("error, port missing\n");
                           break;
                         case 1:
                           if (rc!=0)
                             my_exit("error, timeout missing\n");
                           break;
                         case 2:
                           if (rc!=0)
                             my_exit("error, first object-id missing\n");
                           break;
                         default:
                           if (rc!=0)
                             last_valid_n--;
                           break;
                       }
           };
                 break;
            case WRITE:
            case WRITE_W:
            case WRITE_INHIBIT:
             if (operation!=CMD_NOTHING)
                   my_exit("contradicting options\n");
                 switch (opt)
                   {
                     case WRITE:
                       operation=CMD_WRITE; break;
                     case WRITE_W:
                       operation=CMD_WRITE_W; break;
                     case WRITE_INHIBIT:
                       operation=CMD_WRITE_INHIBIT; break;
                   }
                 l=2;
                 if (operation==CMD_WRITE_INHIBIT)
                   l=3; /* one more parameter */
             for(i=0; i<=l; i++)
                   {
                     rc= match_int(argc, argv, &opt_index, &(n[i]));
                     if (rc==-1)
                       my_exit("error, argument missing\n");
                     if (rc==-2)
                       my_exit("error, argument is not a number\n");
           };
                 break;
      }; /* switch */
      }; /* while */
    if (interface_no==0)
      {
        printf("Error, no interfaces defined\n");
        return 1;
      }
    if (!init_socan(interfaces, interface_no,
                    tracelevel, errprintlevel,
                    rt_prios[0], rt_prios[1]))
      return 1;
    switch(operation)
      {
        case CMD_NOTHING:
             printf("error, no command given\n");
             return 1;
    case CMD_RWTEST:
         test_simple_rw(n[0], n[1], n[2], n[3], n[4], n[5],
                    flag);
         break;
        case CMD_READ:
        case CMD_READ_NOW:
         test_read(n[0], n[1], n[2],
                   loops, sleep, quietlevel,
                   (operation==CMD_READ_NOW),
                   countsize, flag);
         break;
    case CMD_QUEUE_READ:
         test_queue_read(n[0], n[1], n+2, last_valid_n-1,
                     loops, sleep,
                         quietlevel, countsize, flag);
         break;
    case CMD_WRITE:
    case CMD_WRITE_W:
        case CMD_WRITE_INHIBIT:
         test_write(n[0], n[1], n[2], n[3],
                loops, sleep, quietlevel,
                operation,
                countsize,countstart,
                    flag);
         break;
      }
    return(0);
  }