usr_targ_x86.c

一个iSCSI协议实现源代码

              }
              bytes_to_read -= bytes_read;
              if (bytes_to_read) {
                      printf ("warning - short read\n");
              }
      }
      cur_cmnd->received += len;

#if DO_FILE_IO
      printf ("Writing %d bytes at %d\n", len, cur_cmnd->block_no*512 + hdr->scsi_write.buf_offset);
      lseek(global_fd, cur_cmnd->block_no*512 + hdr->scsi_write.buf_offset, SEEK_SET);
      write(global_fd, buffer, len);
#endif

      if (cur_cmnd->received >= (cur_cmnd->num_blocks * 512)){
              memset(&rsp, 0, sizeof(rsp));
              rsp.scsi_rsp.op = ISCSI_OP_SCSI_RSP;
              rsp.scsi_rsp.len = 0;
              rsp.scsi_rsp.itt = hdr->scsi_write.itt;
              rsp.scsi_rsp.stat_rn = cur_statrn++;
              rsp.scsi_rsp.max_cmd_rn = rsp.scsi_rsp.exp_cmd_rn = ++exp_cmdrn;
              rsp.scsi_rsp.status = GOOD;
	
              rsp = cpu_to_be_iscsi(rsp);

              while (bytes_to_write) {
                      if ((bytes_written = write (sock, 
                                                  ((byte *) &rsp) + (ISCSI_HDR_SIZE - bytes_to_write),
                                                  bytes_to_write)) == -1) {
                              perror ("write failed\n");
                              exit(1);
                      }
                      if (bytes_written == 0) {
                              perror ("Client disconnected\n");
                              exit(1);
                      }
                      bytes_to_write -= bytes_written;
                      if (bytes_to_write) {
                              printf ("warning - short write\n");
                      }
              }
              
              trail_cmnd = cmnds;
              if (cmnds == cur_cmnd){
                      cmnds = cur_cmnd->next;
                      free(cur_cmnd);
              }
              else {
                      while (trail_cmnd && trail_cmnd->next != cur_cmnd) 
                              trail_cmnd = trail_cmnd->next;
                      if (trail_cmnd == NULL){
                              printf("ack, cant find the cmnd to free\n");
                              exit (1);
                      }
                      else{
                              trail_cmnd->next = cur_cmnd->next;
                              free(cur_cmnd);
                      }
              }
      }
      
      free(buffer);
      return 0;
}


int rx_scsi_cmd(int sock, iscsi_header_t* hdr)
{
      struct cmd_table * cur_cmnd;
      iscsi_header_t rsp;

      byte *data;

      u32 size;
      u32 block_no, num_blocks;

      int len = hdr->scsi_cmd.exp_data_len, bytes_to_write = ISCSI_HDR_SIZE, bytes_written;

      unsigned char *cdb=hdr->scsi_cmd.cdb;

      if (hdr->scsi_cmd.len != 0) {
              printf ("scsi_cmd with data\n");
      }

      memset(&rsp, 0, sizeof(rsp));

      switch(cdb[0]){
          case TEST_UNIT_READY:
              printf("received TEST_UNIT_READY\n");
              rsp.scsi_rsp.resid_cnt = len;
              if (rsp.scsi_rsp.resid_cnt) rsp.scsi_rsp.flags |= 0x1;
              break;
          case INQUIRY:
              printf("received INQUIRY\n");
              data = malloc(ISCSI_HDR_SIZE + len);
              memset(data, 0, ISCSI_HDR_SIZE + len);

              rsp.op = ISCSI_OP_READ_DATA;
              rsp.scsi_read.len = len;
              rsp.scsi_read.ttt = hdr->scsi_cmd.itt;
              rsp.scsi_read.itt = hdr->scsi_cmd.itt;
              rsp.scsi_read.resid_cnt = 0x0;
              data[50] = 0x3;
              data[51] = 0x2;
              data[52] = 0x40;
              data[55] = 0x2;
              data[56] = 'i';
              data[57] = 'S';
              data[58] = 'C';
              data[59] = 'S';
              data[60] = 'I';
              data[64] = 'F';
              data[65] = 'a';
              data[66] = 'k';
              data[67] = 'e';
              data[83] = '1';
              
              if (hdr->scsi_cmd.lun != 0)
                data[ISCSI_HDR_SIZE] = 0x60;

              printf ("Lun recieved is %d\n", hdr->scsi_cmd.lun);

              rsp = cpu_to_be_iscsi (rsp);
              memcpy (data, &rsp, ISCSI_HDR_SIZE);

              /*DUMP_DATA (data + ISCSI_HDR_SIZE, len);*/

              bytes_to_write = ISCSI_HDR_SIZE + len;

              while (bytes_to_write) {
                      if ((bytes_written = write (sock, 
                                                  data + (ISCSI_HDR_SIZE + len - bytes_to_write),
                                                  bytes_to_write)) == -1) {
                              perror ("write failed\n");
                              exit(1);
                      }
                      if (bytes_written == 0) {
                              perror ("Client disconnected\n");
                              exit(1);
                      }
                      bytes_to_write -= bytes_written;
                      if (bytes_to_write) {
                              printf ("warning - short write\n");
                      }
              }
              free (data);
              
              memset (&rsp, 0, ISCSI_HDR_SIZE);

              break;
          case READ_CAPACITY:
              printf("received READ_CAPACITY\n");
              data = malloc(ISCSI_HDR_SIZE + len);
              memset(data, 0, ISCSI_HDR_SIZE + len);
              rsp.op = ISCSI_OP_READ_DATA;
              rsp.scsi_read.len = len;
              rsp.scsi_read.ttt = hdr->scsi_cmd.itt;
              rsp.scsi_read.itt = hdr->scsi_cmd.itt;
              rsp.scsi_read.resid_cnt = 0x0;
#if DO_FILE_IO
              data[ISCSI_HDR_SIZE+1] = 0x08;
#else
              data[ISCSI_HDR_SIZE] = 0x2;
#endif
              data[ISCSI_HDR_SIZE+6] = 0x2;

              rsp = cpu_to_be_iscsi (rsp);
              memcpy (data, &rsp, ISCSI_HDR_SIZE);

              bytes_to_write = len + ISCSI_HDR_SIZE;
        
              while (bytes_to_write) {
                      if ((bytes_written = write (sock, 
                                                  data + (len + ISCSI_HDR_SIZE - bytes_to_write),
                                                  bytes_to_write)) == -1) {
                              perror ("write failed\n");
                              exit(1);
                      }
                      if (bytes_written == 0) {
                              perror ("Client disconnected\n");
                              exit(1);
                      }
                      bytes_to_write -= bytes_written;
                      if (bytes_to_write) {
                              printf ("warning - short write\n");
                      }
              }
              free (data);

              memset (&rsp, 0, ISCSI_HDR_SIZE);

              break;
          case READ_10:
              size = hdr->raw[39] << 8;
              size += hdr->raw[40];
              size = size*512;
              printf("received READ_10 of size %d\n", size);
              data = malloc(size + ISCSI_HDR_SIZE);
              if (data == NULL){
                      printf("couldnt allocate memory in read_10\n");
                      errno = 0;
                      break;
              }
              memset(data, 0, size+ISCSI_HDR_SIZE);
              rsp.op = ISCSI_OP_READ_DATA;
              rsp.scsi_read.len = size;
              rsp.scsi_read.ttt = hdr->scsi_cmd.itt;
              rsp.scsi_read.itt = hdr->scsi_cmd.itt;
              rsp.scsi_read.resid_cnt = len - size;
              if (rsp.scsi_read.resid_cnt) {
                      printf("Warning RESID IN READ_10\n");
              }
              if (len - size > 0) 
                      rsp.scsi_read.flags |= 0x2;
              else if (len - size < 0) 
                      rsp.scsi_read.flags |= 0x1;
              
              num_blocks = hdr->raw[39] << 8;
              num_blocks += hdr->raw[40];
              block_no = hdr->raw[34] << 24;
              block_no += hdr->raw[35] << 16;
              block_no += hdr->raw[36] << 8;
              block_no += hdr->raw[37];
#if DO_FILE_IO
              printf ("Reading %d bytes from location %d\n", num_blocks*512, block_no*512);
              lseek(global_fd, block_no*512, SEEK_SET);
              read(global_fd, data+ISCSI_HDR_SIZE, num_blocks*512);
#else
              {
                      int i;
                      for (i=0; i<num_blocks; i++){
                              memset(data+ISCSI_HDR_SIZE+(i*512), i, 512);
                      }
              }
#endif
              rsp = cpu_to_be_iscsi (rsp);
              memcpy (data, &rsp, ISCSI_HDR_SIZE);
              
              bytes_to_write = size + ISCSI_HDR_SIZE;

              while (bytes_to_write) {
                      if ((bytes_written = write (sock, 
                                                  data + (size + ISCSI_HDR_SIZE - bytes_to_write),
                                                  bytes_to_write)) == -1) {
                              perror ("write failed\n");
                              exit(1);
                      }
                      if (bytes_written == 0) {
                              perror ("Client disconnected\n");
                              exit(1);
                      }
                      bytes_to_write -= bytes_written;
                      if (bytes_to_write) {
                              printf ("warning - short write\n");
                      }
              }
              free (data);

              memset (&rsp, 0, ISCSI_HDR_SIZE);

              break;

          case WRITE_10:
              if (cmnds == NULL){
                      cmnds = malloc(sizeof(struct cmd_table));
                      cur_cmnd = cmnds;
              }
              else {
                      cur_cmnd = cmnds;
                      while (cur_cmnd->next) cur_cmnd = cur_cmnd->next;
                      cur_cmnd->next = malloc(sizeof(struct cmd_table));
                      cur_cmnd = cur_cmnd->next;
              }
              cur_cmnd->next = NULL;
              cur_cmnd->opcode = WRITE_10;
              cur_cmnd->data_dir = WRITE_TYPE;
              cur_cmnd->received = 0;
              cur_cmnd->block_no = hdr->raw[34] << 24;
              cur_cmnd->block_no += hdr->raw[35] << 16;
              cur_cmnd->block_no += hdr->raw[36] << 8;
              cur_cmnd->block_no += hdr->raw[37];
              cur_cmnd->num_blocks = hdr->raw[39] << 8;
              cur_cmnd->num_blocks += hdr->raw[40];
              size = cur_cmnd->num_blocks*512;
              printf("received WRITE_10 of size %x, block_no %x\n", size, cur_cmnd->block_no);

              rsp.op = ISCSI_OP_R2T;
              rsp.r2t.len = 0;
              rsp.r2t.itt = hdr->scsi_cmd.itt;
              cur_cmnd->task_id = rsp.r2t.ttt = hdr->scsi_cmd.itt;
              rsp.r2t.desired_data_len = size;

              rsp = cpu_to_be_iscsi (rsp);

              bytes_to_write = ISCSI_HDR_SIZE;

              while (bytes_to_write) {
                      if ((bytes_written = write (sock, 
                                                  ((byte *)&rsp) + (ISCSI_HDR_SIZE - bytes_to_write),
                                                  bytes_to_write)) == -1) {
                              perror ("write failed\n");
                              exit(1);
                      }
                      if (bytes_written == 0) {
                              perror ("Client disconnected\n");
                              exit(1);
                      }
                      bytes_to_write -= bytes_written;
                      if (bytes_to_write) {
                              printf ("warning - short write\n");
                      }
              }

              return 0;
              break;
          default:
              printf("received unknown scsi cmd %x\n", hdr->scsi_cmd.cdb[0]);
              iscsi_print_header (hdr);
              break;
      }

      rsp.op = ISCSI_OP_SCSI_RSP;
      rsp.scsi_rsp.len = 0;
      rsp.scsi_rsp.itt = hdr->scsi_cmd.itt;
      rsp.scsi_rsp.stat_rn = cur_statrn++;
      exp_cmdrn = hdr->scsi_cmd.cmd_rn;
      rsp.scsi_rsp.max_cmd_rn = rsp.scsi_rsp.exp_cmd_rn = ++exp_cmdrn;

      rsp = cpu_to_be_iscsi (rsp);

      bytes_to_write = ISCSI_HDR_SIZE;

      while (bytes_to_write) {
              if ((bytes_written = write (sock, 
                                          ((byte *) &rsp) + (ISCSI_HDR_SIZE - bytes_to_write),
                                          bytes_to_write)) == -1) {
                      perror ("write failed\n");
                      exit(1);
              }
              if (bytes_written == 0) {
                      perror ("Client disconnected\n");
                      exit(1);
              }
              bytes_to_write -= bytes_written;
              if (bytes_to_write) {
                      printf ("warning - short write\n");
              }
      }
        
      return 0;
}

int init_server()
{
        struct sockaddr_in addr;
        int sock, sock2, option_value = 1, wild_card = INADDR_ANY, addrlen;

        if ((sock = socket(AF_INET, SOCK_STREAM, 0)) == -1) {
                perror ("socket() failed");
                exit (1);
        }
        
        memcpy(&addr.sin_addr, &wild_card, sizeof(int));
        addr.sin_family = AF_INET;
        addr.sin_port = htons(ISCSI_PORT);
        
        if (setsockopt (sock, SOL_SOCKET, SO_REUSEADDR, 
                        (char *) &option_value, sizeof (option_value)) == -1) {
                perror ("setsockopt() failed");   
                exit (1);
        }
        
        if (bind(sock, (struct sockaddr *) &addr, sizeof(struct sockaddr_in)) == -1) {
                perror ("bind() failed");   
                exit (1);
        }

        if (listen(sock, 1) == -1) {
                perror ("listen() failed");
                exit (1);
        }

        printf ("Waiting for connection..........\n");

        while (((sock2 = accept(sock, (struct sockaddr *) &addr, &addrlen)) == -1) && errno == EINTR);
        if (sock2 == -1) {
                perror ("accept() failed");
                exit(1);
        }

        printf ("Connection!!\n");

        return sock2;
}