sbin/iscontrol/fsm.c

   1 /*-
   2  * Copyright (c) 2005-2008 Daniel Braniss <danny@cs.huji.ac.il>
   3  * All rights reserved.
   4  *
   5  * Redistribution and use in source and binary forms, with or without
   6  * modification, are permitted provided that the following conditions
   7  * are met:
   8  * 1. Redistributions of source code must retain the above copyright
   9  *    notice, this list of conditions and the following disclaimer.
  10  * 2. Redistributions in binary form must reproduce the above copyright
  11  *    notice, this list of conditions and the following disclaimer in the
  12  *    documentation and/or other materials provided with the distribution.
  13  *
  14  * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
  15  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  16  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
  17  * ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
  18  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
  19  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
  20  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
  21  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
  22  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
  23  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
  24  * SUCH DAMAGE.
  25  *
  26  */
  27
  28 /*
  29  | $Id: fsm.c,v 2.8 2007/05/19 16:34:21 danny Exp danny $
  30  */
  31
  32 #include <sys/cdefs.h>
  33
  34 #include <sys/param.h>
  35 #include <sys/types.h>
  36 #include <sys/socket.h>
  37 #include <sys/sysctl.h>
  38
  39 #include <netinet/in.h>
  40 #include <netinet/tcp.h>
  41 #include <arpa/inet.h>
  42 #if __FreeBSD_version < 500000
  43 #include <sys/time.h>
  44 #endif
  45 #include <sys/ioctl.h>
  46 #include <netdb.h>
  47 #include <stdlib.h>
  48 #include <unistd.h>
  49 #include <stdio.h>
  50 #include <string.h>
  51 #include <errno.h>
  52 #include <fcntl.h>
  53 #include <time.h>
  54 #include <syslog.h>
  55 #include <stdarg.h>
  56 #include <camlib.h>
  57
  58 #include "iscsi.h"
  59 #include "iscontrol.h"
  60
  61 typedef enum {
  62      T1 = 1,
  63      T2, /*T3,*/ T4, T5, /*T6,*/ T7, T8, T9,
  64      T10, T11, T12, T13, T14, T15, T16, T18
  65 } trans_t;
  66
  67 /*
  68  | now supports IPV6
  69  | thanks to:
  70  |      Hajimu UMEMOTO @ Internet Mutual Aid Society Yokohama, Japan
  71  |      ume@mahoroba.org  ume@{,jp.}FreeBSD.org
  72  |      http://www.imasy.org/~ume/
  73  */
  74 static trans_t
  75 tcpConnect(isess_t *sess)
  76 {
  77      isc_opt_t *op = sess->op;
  78      int        val, sv_errno, soc;
  79      struct     addrinfo *res, *res0, hints;
  80      char       pbuf[10];
  81
  82      debug_called(3);
  83      if(sess->flags & (SESS_RECONNECT|SESS_REDIRECT)) {
  84           syslog(LOG_INFO, "%s", (sess->flags & SESS_RECONNECT)
  85                  ? "Reconnect": "Redirected");
  86
  87           debug(1, "%s", (sess->flags & SESS_RECONNECT) ? "Reconnect": "Redirected");
  88           shutdown(sess->soc, SHUT_RDWR);
  89           //close(sess->soc);
  90           sess->soc = -1;
  91
  92           sess->flags &= ~SESS_CONNECTED;
  93           if(sess->flags & SESS_REDIRECT) {
  94                sess->redirect_cnt++;
  95                sess->flags |= SESS_RECONNECT;
  96           } else
  97                sleep(2); // XXX: actually should be ?
  98 #ifdef notyet
  99           {
 100                time_t   sec;
 101           // make sure we are not in a loop
 102           // XXX: this code has to be tested
 103           sec = time(0) - sess->reconnect_time;
 104           if(sec > (5*60)) {
 105                // if we've been connected for more that 5 minutes
 106                // then just reconnect
 107                sess->reconnect_time = sec;
 108                sess->reconnect_cnt1 = 0;
 109           }
 110           else {
 111                //
 112                sess->reconnect_cnt1++;
 113                if((sec / sess->reconnect_cnt1) < 2) {
 114                     // if less that 2 seconds from the last reconnect
 115                     // we are most probably looping
 116                     syslog(LOG_CRIT, "too many reconnects %d", sess->reconnect_cnt1);
 117                     return 0;
 118                }
 119           }
 120      }
 121 #endif
 122           sess->reconnect_cnt++;
 123      }
 124
 125      snprintf(pbuf, sizeof(pbuf), "%d", op->port);
 126      memset(&hints, 0, sizeof(hints));
 127      hints.ai_family    = PF_UNSPEC;
 128      hints.ai_socktype  = SOCK_STREAM;
 129      debug(1, "targetAddress=%s port=%d", op->targetAddress, op->port);
 130      if((val = getaddrinfo(op->targetAddress, pbuf, &hints, &res0)) != 0) {
 131           fprintf(stderr, "getaddrinfo(%s): %s\n", op->targetAddress, gai_strerror(val));
 132           return 0;
 133      }
 134      sess->flags &= ~SESS_CONNECTED;
 135      sv_errno = 0;
 136      soc = -1;
 137      for(res = res0; res; res = res->ai_next) {
 138           soc = socket(res->ai_family, res->ai_socktype, res->ai_protocol);
 139           if (soc == -1)
 140                continue;
 141
 142      // from Patrick.Guelat@imp.ch:
 143      // iscontrol can be called without waiting for the socket entry to time out
 144           val = 1;
 145           if(setsockopt(soc, SOL_SOCKET, SO_REUSEADDR, &val, (socklen_t)sizeof(val)) < 0) {
 146                   fprintf(stderr, "Cannot set socket SO_REUSEADDR %d: %s\n\n",
 147                                   errno, strerror(errno));
 148           }
 149           if(connect(soc, res->ai_addr, res->ai_addrlen) == 0)
 150              break;
 151
 152           sv_errno = errno;
 153           close(soc);
 154           soc = -1;
 155      }
 156      freeaddrinfo(res0);
 157
 158      if(soc != -1) {
 159           sess->soc = soc;
 160
 161           /* Default to TCP_NODELAY to improve transfers */
 162           if(setsockopt(sess->soc, IPPROTO_TCP, TCP_NODELAY, &val, sizeof(val)) < 0)
 163                   fprintf(stderr, "Cannot set socket NO delay option err=%d %s\n",
 164                                   errno, strerror(errno));
 165
 166 #if 0
 167           struct        timeval timeout;
 168
 169           val = 1;
 170           if(setsockopt(sess->soc, IPPROTO_TCP, TCP_KEEPALIVE, &val, sizeof(val)) < 0)
 171                fprintf(stderr, "Cannot set socket KEEPALIVE option err=%d %s\n",
 172                        errno, strerror(errno));
 173
 174           if(setsockopt(sess->soc, IPPROTO_TCP, TCP_NODELAY, &val, sizeof(val)) < 0)
 175                fprintf(stderr, "Cannot set socket NO delay option err=%d %s\n",
 176                        errno, strerror(errno));
 177
 178           timeout.tv_sec = 10;
 179           timeout.tv_usec = 0;
 180           if((setsockopt(sess->soc, SOL_SOCKET, SO_SNDTIMEO, &timeout, sizeof(timeout)) < 0)
 181              || (setsockopt(sess->soc, SOL_SOCKET, SO_RCVTIMEO, &timeout, sizeof(timeout)) < 0)) {
 182                fprintf(stderr, "Cannot set socket timeout to %ld err=%d %s\n",
 183                        timeout.tv_sec, errno, strerror(errno));
 184           }
 185 #endif
 186 #ifdef CURIOUS
 187           {
 188                int len = sizeof(val);
 189                if(getsockopt(sess->soc, SOL_SOCKET, SO_SNDBUF, &val, &len) == 0)
 190                     fprintf(stderr, "was: SO_SNDBUF=%dK\n", val/1024);
 191           }
 192 #endif
 193           if(sess->op->sockbufsize) {
 194                val = sess->op->sockbufsize * 1024;
 195                if((setsockopt(sess->soc, SOL_SOCKET, SO_SNDBUF, &val, sizeof(val)) < 0)
 196                   || (setsockopt(sess->soc, SOL_SOCKET, SO_RCVBUF, &val, sizeof(val)) < 0)) {
 197                     fprintf(stderr, "Cannot set socket sndbuf & rcvbuf to %d err=%d %s\n",
 198                             val, errno, strerror(errno));
 199                     return 0;
 200                }
 201           }
 202           sess->flags |= SESS_CONNECTED;
 203           return T1;
 204      }
 205
 206      fprintf(stderr, "errno=%d\n", sv_errno);
 207      perror("connect");
 208      switch(sv_errno) {
 209      case ECONNREFUSED:
 210      case ENETUNREACH:
 211      case ETIMEDOUT:
 212           if((sess->flags & SESS_REDIRECT) == 0) {
 213                if(strcmp(op->targetAddress, sess->target.address) != 0) {
 214                     syslog(LOG_INFO, "reconnecting to original target address");
 215                     free(op->targetAddress);
 216                     op->targetAddress           = sess->target.address;
 217                     op->port                    = sess->target.port;
 218                     op->targetPortalGroupTag    = sess->target.pgt;
 219                     return T1;
 220                }
 221           }
 222           sleep(5); // for now ...
 223           return T1;
 224      default:
 225           return 0; // terminal error
 226      }
 227 }
 228
 229 int
 230 setOptions(isess_t *sess, int flag)
 231 {
 232      isc_opt_t  oop;
 233      char       *sep;
 234
 235      debug_called(3);
 236
 237      bzero(&oop, sizeof(isc_opt_t));
 238
 239      if((flag & SESS_FULLFEATURE) == 0) {
 240           oop.initiatorName     = sess->op->initiatorName;
 241           oop.targetAddress     = sess->op->targetAddress;
 242           if(sess->op->targetName != 0)
 243                oop.targetName = sess->op->targetName;
 244
 245           oop.maxRecvDataSegmentLength = sess->op->maxRecvDataSegmentLength;
 246           oop.maxXmitDataSegmentLength = sess->op->maxXmitDataSegmentLength; // XXX:
 247           oop.maxBurstLength = sess->op->maxBurstLength;
 248           oop.maxluns = sess->op->maxluns;
 249      }
 250      else {
 251           /*
 252            | turn on digestion only after login
 253            */
 254           if(sess->op->headerDigest != NULL) {
 255                sep = strchr(sess->op->headerDigest, ',');
 256                if(sep == NULL)
 257                     oop.headerDigest = sess->op->headerDigest;
 258                debug(1, "oop.headerDigest=%s", oop.headerDigest);
 259           }
 260           if(sess->op->dataDigest != NULL) {
 261                sep = strchr(sess->op->dataDigest, ',');
 262                if(sep == NULL)
 263                     oop.dataDigest = sess->op->dataDigest;
 264                debug(1, "oop.dataDigest=%s", oop.dataDigest);
 265           }
 266      }
 267
 268      if(ioctl(sess->fd, ISCSISETOPT, &oop)) {
 269           perror("ISCSISETOPT");
 270           return -1;
 271      }
 272      return 0;
 273 }
 274
 275 static trans_t
 276 startSession(isess_t *sess)
 277 {
 278
 279      int        n, fd, nfd;
 280      char       *dev;
 281
 282      debug_called(3);
 283
 284      if((sess->flags & SESS_CONNECTED) == 0) {
 285           return T2;
 286      }
 287      if(sess->fd == -1) {
 288           fd = open(iscsidev, O_RDWR);
 289           if(fd < 0) {
 290                perror(iscsidev);
 291                return 0;
 292           }
 293           {
 294                // XXX: this has to go
 295                size_t   n;
 296                n = sizeof(sess->isid);
 297                if(sysctlbyname("net.iscsi.isid", (void *)sess->isid, (size_t *)&n, 0, 0) != 0)
 298                     perror("sysctlbyname");
 299           }
 300           if(ioctl(fd, ISCSISETSES, &n)) {
 301                perror("ISCSISETSES");
 302                return 0;
 303           }
 304           sleep(1);     /* XXX temporary */
 305           asprintf(&dev, "%s%d", iscsidev, n);
 306           nfd = open(dev, O_RDWR);
 307           if(nfd < 0) {
 308                perror(dev);
 309                free(dev);
 310                return 0;
 311           }
 312           free(dev);
 313           close(fd);
 314           sess->fd = nfd;
 315
 316           if(setOptions(sess, 0) != 0)
 317                return -1;
 318      }
 319
 320      if(ioctl(sess->fd, ISCSISETSOC, &sess->soc)) {
 321           perror("ISCSISETSOC");
 322           return 0;
 323      }
 324
 325      return T4;
 326 }
 327
 328 isess_t *currsess;
 329
 330 static void
 331 trap(int sig)
 332 {
 333      syslog(LOG_NOTICE, "trapped signal %d", sig);
 334      fprintf(stderr, "trapped signal %d\n", sig);
 335
 336      switch(sig) {
 337      case SIGHUP:
 338           currsess->flags |= SESS_DISCONNECT;
 339           break;
 340
 341      case SIGUSR1:
 342           currsess->flags |= SESS_RECONNECT;
 343           break;
 344
 345      case SIGINT:
 346      case SIGTERM:
 347      default:
 348           return; // ignore
 349      }
 350 }
 351
 352 static void
 353 doCAM(isess_t *sess)
 354 {
 355      char       pathstr[1024];
 356      union ccb  *ccb;
 357      int        i;
 358
 359      if(ioctl(sess->fd, ISCSIGETCAM, &sess->cam) != 0) {
 360           syslog(LOG_WARNING, "ISCSIGETCAM failed: %d", errno);
 361           return;
 362      }
 363      debug(2, "nluns=%d", sess->cam.target_nluns);
 364      /*
 365       | for now will do this for each lun ...
 366       */
 367      for(i = 0; i < sess->cam.target_nluns; i++) {
 368           debug(2, "CAM path_id=%d target_id=%d target_lun=%d",
 369                 sess->cam.path_id, sess->cam.target_id, sess->cam.target_lun[i]);
 370
 371           sess->camdev = cam_open_btl(sess->cam.path_id, sess->cam.target_id,
 372                                       sess->cam.target_lun[i], O_RDWR, NULL);
 373           if(sess->camdev == NULL) {
 374                syslog(LOG_WARNING, "%s", cam_errbuf);
 375                debug(3, "%s", cam_errbuf);
 376                continue;
 377           }
 378
 379           cam_path_string(sess->camdev, pathstr, sizeof(pathstr));
 380           debug(2, "pathstr=%s", pathstr);
 381
 382           ccb = cam_getccb(sess->camdev);
 383           bzero(&(&ccb->ccb_h)[1], sizeof(struct ccb_relsim) - sizeof(struct ccb_hdr));
 384           ccb->ccb_h.func_code = XPT_REL_SIMQ;
 385           ccb->crs.release_flags = RELSIM_ADJUST_OPENINGS;
 386           ccb->crs.openings = sess->op->tags;
 387
 388           if(cam_send_ccb(sess->camdev, ccb) < 0)
 389                syslog(LOG_WARNING, "%s", cam_errbuf);
 390           else
 391           if((ccb->ccb_h.status & CAM_STATUS_MASK) != CAM_REQ_CMP) {
 392                syslog(LOG_WARNING, "XPT_REL_SIMQ CCB failed");
 393                // cam_error_print(sess->camdev, ccb, CAM_ESF_ALL, CAM_EPF_ALL, stderr);
 394           }
 395           else
 396                syslog(LOG_INFO, "%s tagged openings now %d\n", pathstr, ccb->crs.openings);
 397
 398           cam_freeccb(ccb);
 399           cam_close_device(sess->camdev);
 400      }
 401 }
 402
 403 static trans_t
 404 supervise(isess_t *sess)
 405 {
 406      int        sig, val;
 407
 408      debug_called(3);
 409
 410      if(strcmp(sess->op->sessionType, "Discovery") == 0) {
 411           sess->flags |= SESS_DISCONNECT;
 412           return T9;
 413      }
 414
 415      if(vflag)
 416           printf("ready to go scsi\n");
 417
 418      if(setOptions(sess, SESS_FULLFEATURE) != 0)
 419           return 0; // failure
 420
 421      if((sess->flags & SESS_FULLFEATURE) == 0) {
 422           if(daemon(0, 1) != 0) {
 423                perror("daemon");
 424                exit(1);
 425           }
 426
 427           openlog("iscontrol", LOG_CONS|LOG_PERROR|LOG_PID|LOG_NDELAY, LOG_KERN);
 428           syslog(LOG_INFO, "running");
 429
 430           currsess = sess;
 431           if(ioctl(sess->fd, ISCSISTART)) {
 432                perror("ISCSISTART");
 433                return -1;
 434           }
 435           doCAM(sess);
 436
 437      }
 438      else {
 439           if(ioctl(sess->fd, ISCSIRESTART)) {
 440                perror("ISCSIRESTART");
 441                return -1;
 442           }
 443      }
 444
 445      signal(SIGINT, trap);
 446      signal(SIGHUP, trap);
 447      signal(SIGTERM, trap);
 448
 449      sig = SIGUSR1;
 450      signal(sig, trap);
 451      if(ioctl(sess->fd, ISCSISIGNAL, &sig)) {
 452           perror("ISCSISIGNAL");
 453           return -1;
 454      }
 455      sess->flags |= SESS_FULLFEATURE;
 456
 457      sess->flags &= ~(SESS_REDIRECT | SESS_RECONNECT);
 458      printf("iscontrol: supervise starting main loop\n");
 459      /*
 460       | the main loop - actually do nothing
 461       | all the work is done inside the kernel
 462       */
 463      while((sess->flags & (SESS_REDIRECT|SESS_RECONNECT|SESS_DISCONNECT)) == 0) {
 464           // do something?
 465           // like sending a nop_out?
 466           sleep(60);
 467      }
 468      printf("iscontrol: supervise going down\n");
 469      syslog(LOG_INFO, "sess flags=%x", sess->flags);
 470
 471      sig = 0;
 472      if(ioctl(sess->fd, ISCSISIGNAL, &sig)) {
 473           perror("ISCSISIGNAL");
 474      }
 475
 476      if(sess->flags & SESS_DISCONNECT) {
 477           val = 0;
 478           if(ioctl(sess->fd, ISCSISTOP, &val)) {
 479                perror("ISCSISTOP");
 480           }
 481           sess->flags &= ~SESS_FULLFEATURE;
 482           return T9;
 483      }
 484      else {
 485           sess->flags |= SESS_INITIALLOGIN1;
 486      }
 487      return T8;
 488 }
 489
 490 static int
 491 handledDiscoveryResp(isess_t *sess, pdu_t *pp)
 492 {
 493      u_char     *ptr;
 494      int        len, n;
 495
 496      debug_called(3);
 497
 498      len = pp->ds_len;
 499      ptr = pp->ds;
 500      while(len > 0) {
 501           if(*ptr != 0)
 502                printf("%s\n", ptr);
 503           n = strlen((char *)ptr) + 1;
 504           len -= n;
 505           ptr += n;
 506      }
 507      return 0;
 508 }
 509
 510 static int
 511 doDiscovery(isess_t *sess)
 512 {
 513      pdu_t      spp;
 514      text_req_t *tp = (text_req_t *)&spp.ipdu.bhs;
 515
 516      debug_called(3);
 517
 518      bzero(&spp, sizeof(pdu_t));
 519      tp->cmd = ISCSI_TEXT_CMD /*| 0x40 */; // because of a bug in openiscsi-target
 520      tp->F = 1;
 521      tp->ttt = 0xffffffff;
 522      addText(&spp, "SendTargets=All");
 523      return sendPDU(sess, &spp, handledDiscoveryResp);
 524 }
 525
 526 static trans_t
 527 doLogin(isess_t *sess)
 528 {
 529      isc_opt_t  *op = sess->op;
 530      int        status, count;
 531
 532      debug_called(3);
 533
 534      if(op->chapSecret == NULL && op->tgtChapSecret == NULL)
 535           /*
 536            | don't need any security negotiation
 537            | or in other words: we don't have any secrets to exchange
 538            */
 539           sess->csg = LON_PHASE;
 540      else
 541           sess->csg = SN_PHASE;
 542
 543      if(sess->tsih) {
 544           sess->tsih = 0;       // XXX: no 'reconnect' yet
 545           sess->flags &= ~SESS_NEGODONE; // XXX: KLUDGE
 546      }
 547      count = 10; // should be more than enough
 548      do {
 549           debug(3, "count=%d csg=%d", count, sess->csg);
 550           status = loginPhase(sess);
 551           if(count-- == 0)
 552                // just in case we get into a loop
 553                status = -1;
 554      } while(status == 0 && (sess->csg != FF_PHASE));
 555
 556      sess->flags &= ~SESS_INITIALLOGIN;
 557      debug(3, "status=%d", status);
 558
 559      switch(status) {
 560      case 0: // all is ok ...
 561           sess->flags |= SESS_LOGGEDIN;
 562           if(strcmp(sess->op->sessionType, "Discovery") == 0)
 563                doDiscovery(sess);
 564           return T5;
 565
 566      case 1:    // redirect - temporary/permanent
 567           /*
 568            | start from scratch?
 569            */
 570           sess->flags &= ~SESS_NEGODONE;
 571           sess->flags |= (SESS_REDIRECT | SESS_INITIALLOGIN1);
 572           syslog(LOG_DEBUG, "target sent REDIRECT");
 573           return T7;
 574
 575      case 2: // initiator terminal error
 576           return 0;
 577      case 3: // target terminal error -- could retry ...
 578           sleep(5);
 579           return T7; // lets try
 580      default:
 581           return 0;
 582      }
 583 }
 584
 585 static int
 586 handleLogoutResp(isess_t *sess, pdu_t *pp)
 587 {
 588      if(sess->flags & SESS_DISCONNECT)
 589           return 0;
 590      return T13;
 591 }
 592
 593 static trans_t
 594 startLogout(isess_t *sess)
 595 {
 596      pdu_t      spp;
 597      logout_req_t *p = (logout_req_t *)&spp.ipdu.bhs;
 598
 599      bzero(&spp, sizeof(pdu_t));
 600      p->cmd = ISCSI_LOGOUT_CMD| 0x40;
 601      p->reason = BIT(7) | 0;
 602      p->CID = htons(1);
 603
 604      return sendPDU(sess, &spp, handleLogoutResp);
 605 }
 606
 607 static trans_t
 608 inLogout(isess_t *sess)
 609 {
 610      if(sess->flags & SESS_RECONNECT)
 611           return T18;
 612      return 0;
 613 }
 614
 615 typedef enum {
 616      S1=1, S2, S3, S4, S5, S6, S7, S8
 617 } state_t;
 618 \f
 619 #if 0
 620       S1: FREE
 621       S2: XPT_WAIT
 622       S4: IN_LOGIN
 623       S5: LOGGED_IN
 624       S6: IN_LOGOUT
 625       S7: LOGOUT_REQUESTED
 626       S8: CLEANUP_WAIT
 627
 628                      -------<-------------+
 629          +--------->/ S1    \<----+       |
 630       T13|       +->\       /<-+   \      |
 631          |      /    ---+---    \   \     |
 632          |     /        |     T2 \   |    |
 633          |  T8 |        |T1       |  |    |
 634          |     |        |        /   |T7  |
 635          |     |        |       /    |    |
 636          |     |        |      /     |    |
 637          |     |        V     /     /     |
 638          |     |     ------- /     /      |
 639          |     |    / S2    \     /       |
 640          |     |    \       /    /        |
 641          |     |     ---+---    /         |
 642          |     |        |T4    /          |
 643          |     |        V     /           | T18
 644          |     |     ------- /            |
 645          |     |    / S4    \             |
 646          |     |    \       /             |
 647          |     |     ---+---              |         T15
 648          |     |        |T5      +--------+---------+
 649          |     |        |       /T16+-----+------+  |
 650          |     |        |      /   -+-----+--+   |  |
 651          |     |        |     /   /  S7   \  |T12|  |
 652          |     |        |    / +->\       /<-+   V  V
 653          |     |        |   / /    -+-----       -------
 654          |     |        |  / /T11   |T10        /  S8   \
 655          |     |        V / /       V  +----+   \       /
 656          |     |      ---+-+-      ----+--  |    -------
 657          |     |     / S5    \T9  / S6    \<+    ^
 658          |     +-----\       /--->\       / T14  |
 659          |            -------      --+----+------+T17
 660          +---------------------------+
 661 #endif
 662
 663 int
 664 fsm(isc_opt_t *op)
 665 {
 666      state_t    state;
 667      isess_t    *sess;
 668
 669      if((sess = calloc(1, sizeof(isess_t))) == NULL) {
 670           // boy, is this a bad start ...
 671           fprintf(stderr, "no memory!\n");
 672           return -1;
 673      }
 674
 675      state = S1;
 676      sess->op = op;
 677      sess->fd = -1;
 678      sess->soc = -1;
 679      sess->target.address = strdup(op->targetAddress);
 680      sess->target.port = op->port;
 681      sess->target.pgt = op->targetPortalGroupTag;
 682
 683      sess->flags = SESS_INITIALLOGIN | SESS_INITIALLOGIN1;
 684
 685      do {
 686           switch(state) {
 687           case S1:
 688                switch(tcpConnect(sess)) {
 689                case T1: state = S2; break;
 690                default: state = S8; break;
 691                }
 692                break;
 693
 694           case S2:
 695                switch(startSession(sess)) {
 696                case T2: state = S1; break;
 697                case T4: state = S4; break;
 698                default: state = S8; break;
 699                }
 700                break;
 701
 702           case S4:
 703                switch(doLogin(sess)) {
 704                case T7:  state = S1; break;
 705                case T5:  state = S5; break;
 706                default: state = S8; break;
 707                }
 708                break;
 709
 710           case S5:
 711                switch(supervise(sess)) {
 712                case T8:  state = S1; break;
 713                case T9:  state = S6; break;
 714                case T11: state = S7; break;
 715                case T15: state = S8; break;
 716                default: state = S8; break;
 717                }
 718                break;
 719
 720           case S6:
 721                switch(startLogout(sess)) {
 722                case T13: state = S1; break;
 723                case T14: state = S6; break;
 724                case T16: state = S8; break;
 725                default: state = S8; break;
 726                }
 727                break;
 728
 729           case S7:
 730                switch(inLogout(sess)) {
 731                case T18: state = S1; break;
 732                case T10: state = S6; break;
 733                case T12: state = S7; break;
 734                case T16: state = S8; break;
 735                default: state = S8; break;
 736                }
 737                break;
 738
 739           case S8:
 740                // maybe do some clean up?
 741                syslog(LOG_INFO, "terminated");
 742                return 0;
 743           default:
 744                syslog(LOG_INFO, "unknown state %d", state);
 745                return 0;
 746           }
 747      } while(1);
 748 }