[iscsi] Change default initiator name prefix to "iqn.2000-01.org.etherboot:"
[people/dverkamp/gpxe.git] / src / net / tcp / iscsi.c
1 /*
2  * Copyright (C) 2006 Michael Brown <mbrown@fensystems.co.uk>.
3  *
4  * This program is free software; you can redistribute it and/or
5  * modify it under the terms of the GNU General Public License as
6  * published by the Free Software Foundation; either version 2 of the
7  * License, or any later version.
8  *
9  * This program is distributed in the hope that it will be useful, but
10  * WITHOUT ANY WARRANTY; without even the implied warranty of
11  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
12  * General Public License for more details.
13  *
14  * You should have received a copy of the GNU General Public License
15  * along with this program; if not, write to the Free Software
16  * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
17  */
18
19 #include <stddef.h>
20 #include <string.h>
21 #include <stdlib.h>
22 #include <stdio.h>
23 #include <errno.h>
24 #include <assert.h>
25 #include <byteswap.h>
26 #include <gpxe/vsprintf.h>
27 #include <gpxe/socket.h>
28 #include <gpxe/xfer.h>
29 #include <gpxe/open.h>
30 #include <gpxe/scsi.h>
31 #include <gpxe/process.h>
32 #include <gpxe/uaccess.h>
33 #include <gpxe/tcpip.h>
34 #include <gpxe/settings.h>
35 #include <gpxe/features.h>
36 #include <gpxe/iscsi.h>
37
38 /** @file
39  *
40  * iSCSI protocol
41  *
42  */
43
44 FEATURE ( FEATURE_PROTOCOL, "iSCSI", DHCP_EB_FEATURE_ISCSI, 1 );
45
46 /** iSCSI initiator name (explicitly specified) */
47 static char *iscsi_explicit_initiator_iqn;
48
49 /** Default iSCSI initiator name (constructed from hostname) */
50 static char *iscsi_default_initiator_iqn;
51
52 /** iSCSI initiator username */
53 static char *iscsi_initiator_username;
54
55 /** iSCSI initiator password */
56 static char *iscsi_initiator_password;
57
58 /** iSCSI target username */
59 static char *iscsi_target_username;
60
61 /** iSCSI target password */
62 static char *iscsi_target_password;
63
64 static void iscsi_start_tx ( struct iscsi_session *iscsi );
65 static void iscsi_start_login ( struct iscsi_session *iscsi );
66 static void iscsi_start_data_out ( struct iscsi_session *iscsi,
67                                    unsigned int datasn );
68
69 /**
70  * Finish receiving PDU data into buffer
71  *
72  * @v iscsi             iSCSI session
73  */
74 static void iscsi_rx_buffered_data_done ( struct iscsi_session *iscsi ) {
75         free ( iscsi->rx_buffer );
76         iscsi->rx_buffer = NULL;
77 }
78
79 /**
80  * Free iSCSI session
81  *
82  * @v refcnt            Reference counter
83  */
84 static void iscsi_free ( struct refcnt *refcnt ) {
85         struct iscsi_session *iscsi =
86                 container_of ( refcnt, struct iscsi_session, refcnt );
87
88         free ( iscsi->target_address );
89         free ( iscsi->target_iqn );
90         free ( iscsi->initiator_username );
91         free ( iscsi->initiator_password );
92         free ( iscsi->target_username );
93         free ( iscsi->target_password );
94         chap_finish ( &iscsi->chap );
95         iscsi_rx_buffered_data_done ( iscsi );
96         free ( iscsi );
97 }
98
99 /**
100  * Open iSCSI transport-layer connection
101  *
102  * @v iscsi             iSCSI session
103  * @ret rc              Return status code
104  */
105 static int iscsi_open_connection ( struct iscsi_session *iscsi ) {
106         struct sockaddr_tcpip target;
107         int rc;
108
109         assert ( iscsi->tx_state == ISCSI_TX_IDLE );
110         assert ( iscsi->rx_state == ISCSI_RX_BHS );
111         assert ( iscsi->rx_offset == 0 );
112
113         /* Open socket */
114         memset ( &target, 0, sizeof ( target ) );
115         target.st_port = htons ( iscsi->target_port );
116         if ( ( rc = xfer_open_named_socket ( &iscsi->socket, SOCK_STREAM,
117                                              ( struct sockaddr * ) &target,
118                                              iscsi->target_address,
119                                              NULL ) ) != 0 ) {
120                 DBGC ( iscsi, "iSCSI %p could not open socket: %s\n",
121                        iscsi, strerror ( rc ) );
122                 return rc;
123         }
124
125         /* Enter security negotiation phase */
126         iscsi->status = ( ISCSI_STATUS_SECURITY_NEGOTIATION_PHASE |
127                           ISCSI_STATUS_STRINGS_SECURITY );
128
129         /* Assign fresh initiator task tag */
130         iscsi->itt++;
131
132         /* Initiate login */
133         iscsi_start_login ( iscsi );
134
135         return 0;
136 }
137
138 /**
139  * Close iSCSI transport-layer connection
140  *
141  * @v iscsi             iSCSI session
142  * @v rc                Reason for close
143  *
144  * Closes the transport-layer connection and resets the session state
145  * ready to attempt a fresh login.
146  */
147 static void iscsi_close_connection ( struct iscsi_session *iscsi, int rc ) {
148
149         /* Close all data transfer interfaces */
150         xfer_close ( &iscsi->socket, rc );
151
152         /* Clear connection status */
153         iscsi->status = 0;
154
155         /* Deauthenticate target */
156         iscsi->target_auth_ok = 0;
157
158         /* Reset TX and RX state machines */
159         iscsi->tx_state = ISCSI_TX_IDLE;
160         iscsi->rx_state = ISCSI_RX_BHS;
161         iscsi->rx_offset = 0;
162
163         /* Free any temporary dynamically allocated memory */
164         chap_finish ( &iscsi->chap );
165         iscsi_rx_buffered_data_done ( iscsi );
166 }
167
168 /**
169  * Mark iSCSI SCSI operation as complete
170  *
171  * @v iscsi             iSCSI session
172  * @v rc                Return status code
173  *
174  * Note that iscsi_scsi_done() will not close the connection, and must
175  * therefore be called only when the internal state machines are in an
176  * appropriate state, otherwise bad things may happen on the next call
177  * to iscsi_issue().  The general rule is to call iscsi_scsi_done()
178  * only at the end of receiving a PDU; at this point the TX and RX
179  * engines should both be idle.
180  */
181 static void iscsi_scsi_done ( struct iscsi_session *iscsi, int rc ) {
182
183         assert ( iscsi->tx_state == ISCSI_TX_IDLE );
184
185         iscsi->command = NULL;
186         iscsi->rc = rc;
187 }
188
189 /****************************************************************************
190  *
191  * iSCSI SCSI command issuing
192  *
193  */
194
195 /**
196  * Build iSCSI SCSI command BHS
197  *
198  * @v iscsi             iSCSI session
199  *
200  * We don't currently support bidirectional commands (i.e. with both
201  * Data-In and Data-Out segments); these would require providing code
202  * to generate an AHS, and there doesn't seem to be any need for it at
203  * the moment.
204  */
205 static void iscsi_start_command ( struct iscsi_session *iscsi ) {
206         struct iscsi_bhs_scsi_command *command = &iscsi->tx_bhs.scsi_command;
207
208         assert ( ! ( iscsi->command->data_in && iscsi->command->data_out ) );
209
210         /* Construct BHS and initiate transmission */
211         iscsi_start_tx ( iscsi );
212         command->opcode = ISCSI_OPCODE_SCSI_COMMAND;
213         command->flags = ( ISCSI_FLAG_FINAL |
214                            ISCSI_COMMAND_ATTR_SIMPLE );
215         if ( iscsi->command->data_in )
216                 command->flags |= ISCSI_COMMAND_FLAG_READ;
217         if ( iscsi->command->data_out )
218                 command->flags |= ISCSI_COMMAND_FLAG_WRITE;
219         /* lengths left as zero */
220         command->lun = iscsi->lun;
221         command->itt = htonl ( ++iscsi->itt );
222         command->exp_len = htonl ( iscsi->command->data_in_len |
223                                    iscsi->command->data_out_len );
224         command->cmdsn = htonl ( iscsi->cmdsn );
225         command->expstatsn = htonl ( iscsi->statsn + 1 );
226         memcpy ( &command->cdb, &iscsi->command->cdb, sizeof ( command->cdb ));
227         DBGC2 ( iscsi, "iSCSI %p start " SCSI_CDB_FORMAT " %s %#zx\n",
228                 iscsi, SCSI_CDB_DATA ( command->cdb ),
229                 ( iscsi->command->data_in ? "in" : "out" ),
230                 ( iscsi->command->data_in ?
231                   iscsi->command->data_in_len :
232                   iscsi->command->data_out_len ) );
233 }
234
235 /**
236  * Receive data segment of an iSCSI SCSI response PDU
237  *
238  * @v iscsi             iSCSI session
239  * @v data              Received data
240  * @v len               Length of received data
241  * @v remaining         Data remaining after this data
242  * @ret rc              Return status code
243  */
244 static int iscsi_rx_scsi_response ( struct iscsi_session *iscsi,
245                                     const void *data, size_t len,
246                                     size_t remaining ) {
247         struct iscsi_bhs_scsi_response *response
248                 = &iscsi->rx_bhs.scsi_response;
249         int sense_offset;
250
251         /* Capture the sense response code as it floats past, if present */
252         sense_offset = ISCSI_SENSE_RESPONSE_CODE_OFFSET - iscsi->rx_offset;
253         if ( ( sense_offset >= 0 ) && len ) {
254                 iscsi->command->sense_response =
255                         * ( ( char * ) data + sense_offset );
256         }
257
258         /* Wait for whole SCSI response to arrive */
259         if ( remaining )
260                 return 0;
261         
262         /* Record SCSI status code */
263         iscsi->command->status = response->status;
264
265         /* Check for errors */
266         if ( response->response != ISCSI_RESPONSE_COMMAND_COMPLETE )
267                 return -EIO;
268
269         /* Mark as completed */
270         iscsi_scsi_done ( iscsi, 0 );
271         return 0;
272 }
273
274 /**
275  * Receive data segment of an iSCSI data-in PDU
276  *
277  * @v iscsi             iSCSI session
278  * @v data              Received data
279  * @v len               Length of received data
280  * @v remaining         Data remaining after this data
281  * @ret rc              Return status code
282  */
283 static int iscsi_rx_data_in ( struct iscsi_session *iscsi,
284                               const void *data, size_t len,
285                               size_t remaining ) {
286         struct iscsi_bhs_data_in *data_in = &iscsi->rx_bhs.data_in;
287         unsigned long offset;
288
289         /* Copy data to data-in buffer */
290         offset = ntohl ( data_in->offset ) + iscsi->rx_offset;
291         assert ( iscsi->command != NULL );
292         assert ( iscsi->command->data_in );
293         assert ( ( offset + len ) <= iscsi->command->data_in_len );
294         copy_to_user ( iscsi->command->data_in, offset, data, len );
295
296         /* Wait for whole SCSI response to arrive */
297         if ( remaining )
298                 return 0;
299
300         /* Mark as completed if status is present */
301         if ( data_in->flags & ISCSI_DATA_FLAG_STATUS ) {
302                 assert ( ( offset + len ) == iscsi->command->data_in_len );
303                 assert ( data_in->flags & ISCSI_FLAG_FINAL );
304                 iscsi->command->status = data_in->status;
305                 /* iSCSI cannot return an error status via a data-in */
306                 iscsi_scsi_done ( iscsi, 0 );
307         }
308
309         return 0;
310 }
311
312 /**
313  * Receive data segment of an iSCSI R2T PDU
314  *
315  * @v iscsi             iSCSI session
316  * @v data              Received data
317  * @v len               Length of received data
318  * @v remaining         Data remaining after this data
319  * @ret rc              Return status code
320  */
321 static int iscsi_rx_r2t ( struct iscsi_session *iscsi,
322                           const void *data __unused, size_t len __unused,
323                           size_t remaining __unused ) {
324         struct iscsi_bhs_r2t *r2t = &iscsi->rx_bhs.r2t;
325
326         /* Record transfer parameters and trigger first data-out */
327         iscsi->ttt = ntohl ( r2t->ttt );
328         iscsi->transfer_offset = ntohl ( r2t->offset );
329         iscsi->transfer_len = ntohl ( r2t->len );
330         iscsi_start_data_out ( iscsi, 0 );
331
332         return 0;
333 }
334
335 /**
336  * Build iSCSI data-out BHS
337  *
338  * @v iscsi             iSCSI session
339  * @v datasn            Data sequence number within the transfer
340  *
341  */
342 static void iscsi_start_data_out ( struct iscsi_session *iscsi,
343                                    unsigned int datasn ) {
344         struct iscsi_bhs_data_out *data_out = &iscsi->tx_bhs.data_out;
345         unsigned long offset;
346         unsigned long remaining;
347         unsigned long len;
348
349         /* We always send 512-byte Data-Out PDUs; this removes the
350          * need to worry about the target's MaxRecvDataSegmentLength.
351          */
352         offset = datasn * 512;
353         remaining = iscsi->transfer_len - offset;
354         len = remaining;
355         if ( len > 512 )
356                 len = 512;
357
358         /* Construct BHS and initiate transmission */
359         iscsi_start_tx ( iscsi );
360         data_out->opcode = ISCSI_OPCODE_DATA_OUT;
361         if ( len == remaining )
362                 data_out->flags = ( ISCSI_FLAG_FINAL );
363         ISCSI_SET_LENGTHS ( data_out->lengths, 0, len );
364         data_out->lun = iscsi->lun;
365         data_out->itt = htonl ( iscsi->itt );
366         data_out->ttt = htonl ( iscsi->ttt );
367         data_out->expstatsn = htonl ( iscsi->statsn + 1 );
368         data_out->datasn = htonl ( datasn );
369         data_out->offset = htonl ( iscsi->transfer_offset + offset );
370         DBGC ( iscsi, "iSCSI %p start data out DataSN %#x len %#lx\n",
371                iscsi, datasn, len );
372 }
373
374 /**
375  * Complete iSCSI data-out PDU transmission
376  *
377  * @v iscsi             iSCSI session
378  *
379  */
380 static void iscsi_data_out_done ( struct iscsi_session *iscsi ) {
381         struct iscsi_bhs_data_out *data_out = &iscsi->tx_bhs.data_out;
382
383         /* If we haven't reached the end of the sequence, start
384          * sending the next data-out PDU.
385          */
386         if ( ! ( data_out->flags & ISCSI_FLAG_FINAL ) )
387                 iscsi_start_data_out ( iscsi, ntohl ( data_out->datasn ) + 1 );
388 }
389
390 /**
391  * Send iSCSI data-out data segment
392  *
393  * @v iscsi             iSCSI session
394  * @ret rc              Return status code
395  */
396 static int iscsi_tx_data_out ( struct iscsi_session *iscsi ) {
397         struct iscsi_bhs_data_out *data_out = &iscsi->tx_bhs.data_out;
398         struct io_buffer *iobuf;
399         unsigned long offset;
400         size_t len;
401
402         offset = ntohl ( data_out->offset );
403         len = ISCSI_DATA_LEN ( data_out->lengths );
404
405         assert ( iscsi->command != NULL );
406         assert ( iscsi->command->data_out );
407         assert ( ( offset + len ) <= iscsi->command->data_out_len );
408
409         iobuf = xfer_alloc_iob ( &iscsi->socket, len );
410         if ( ! iobuf )
411                 return -ENOMEM;
412         
413         copy_from_user ( iob_put ( iobuf, len ),
414                          iscsi->command->data_out, offset, len );
415
416         return xfer_deliver_iob ( &iscsi->socket, iobuf );
417 }
418
419 /****************************************************************************
420  *
421  * iSCSI login
422  *
423  */
424
425 /**
426  * Build iSCSI login request strings
427  *
428  * @v iscsi             iSCSI session
429  *
430  * These are the initial set of strings sent in the first login
431  * request PDU.  We want the following settings:
432  *
433  *     HeaderDigest=None
434  *     DataDigest=None
435  *     MaxConnections is irrelevant; we make only one connection anyway
436  *     InitialR2T=Yes [1]
437  *     ImmediateData is irrelevant; we never send immediate data
438  *     MaxRecvDataSegmentLength=8192 (default; we don't care) [3]
439  *     MaxBurstLength=262144 (default; we don't care) [3]
440  *     FirstBurstLength=262144 (default; we don't care)
441  *     DefaultTime2Wait=0 [2]
442  *     DefaultTime2Retain=0 [2]
443  *     MaxOutstandingR2T=1
444  *     DataPDUInOrder=Yes
445  *     DataSequenceInOrder=Yes
446  *     ErrorRecoveryLevel=0
447  *
448  * [1] InitialR2T has an OR resolution function, so the target may
449  * force us to use it.  We therefore simplify our logic by always
450  * using it.
451  *
452  * [2] These ensure that we can safely start a new task once we have
453  * reconnected after a failure, without having to manually tidy up
454  * after the old one.
455  *
456  * [3] We are quite happy to use the RFC-defined default values for
457  * these parameters, but some targets (notably OpenSolaris)
458  * incorrectly assume a default value of zero, so we explicitly
459  * specify the default values.
460  */
461 static int iscsi_build_login_request_strings ( struct iscsi_session *iscsi,
462                                                void *data, size_t len ) {
463         unsigned int used = 0;
464         unsigned int i;
465         const char *auth_method;
466
467         if ( iscsi->status & ISCSI_STATUS_STRINGS_SECURITY ) {
468                 /* Default to allowing no authentication */
469                 auth_method = "None";
470                 /* If we have a credential to supply, permit CHAP */
471                 if ( iscsi->initiator_username )
472                         auth_method = "CHAP,None";
473                 /* If we have a credential to check, force CHAP */
474                 if ( iscsi->target_username )
475                         auth_method = "CHAP";
476                 used += ssnprintf ( data + used, len - used,
477                                     "InitiatorName=%s%c"
478                                     "TargetName=%s%c"
479                                     "SessionType=Normal%c"
480                                     "AuthMethod=%s%c",
481                                     iscsi_initiator_iqn(), 0,
482                                     iscsi->target_iqn, 0, 0,
483                                     auth_method, 0 );
484         }
485
486         if ( iscsi->status & ISCSI_STATUS_STRINGS_CHAP_ALGORITHM ) {
487                 used += ssnprintf ( data + used, len - used, "CHAP_A=5%c", 0 );
488         }
489         
490         if ( ( iscsi->status & ISCSI_STATUS_STRINGS_CHAP_RESPONSE ) ) {
491                 assert ( iscsi->initiator_username != NULL );
492                 used += ssnprintf ( data + used, len - used,
493                                     "CHAP_N=%s%cCHAP_R=0x",
494                                     iscsi->initiator_username, 0 );
495                 for ( i = 0 ; i < iscsi->chap.response_len ; i++ ) {
496                         used += ssnprintf ( data + used, len - used, "%02x",
497                                             iscsi->chap.response[i] );
498                 }
499                 used += ssnprintf ( data + used, len - used, "%c", 0 );
500         }
501
502         if ( ( iscsi->status & ISCSI_STATUS_STRINGS_CHAP_CHALLENGE ) ) {
503                 used += ssnprintf ( data + used, len - used,
504                                     "CHAP_I=%d%cCHAP_C=0x",
505                                     iscsi->chap_challenge[0], 0 );
506                 for ( i = 1 ; i < sizeof ( iscsi->chap_challenge ) ; i++ ) {
507                         used += ssnprintf ( data + used, len - used, "%02x",
508                                             iscsi->chap_challenge[i] );
509                 }
510                 used += ssnprintf ( data + used, len - used, "%c", 0 );
511         }
512
513         if ( iscsi->status & ISCSI_STATUS_STRINGS_OPERATIONAL ) {
514                 used += ssnprintf ( data + used, len - used,
515                                     "HeaderDigest=None%c"
516                                     "DataDigest=None%c"
517                                     "InitialR2T=Yes%c"
518                                     "MaxRecvDataSegmentLength=8192%c"
519                                     "MaxBurstLength=262144%c"
520                                     "DefaultTime2Wait=0%c"
521                                     "DefaultTime2Retain=0%c"
522                                     "MaxOutstandingR2T=1%c"
523                                     "DataPDUInOrder=Yes%c"
524                                     "DataSequenceInOrder=Yes%c"
525                                     "ErrorRecoveryLevel=0%c",
526                                     0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 );
527         }
528
529         return used;
530 }
531
532 /**
533  * Build iSCSI login request BHS
534  *
535  * @v iscsi             iSCSI session
536  */
537 static void iscsi_start_login ( struct iscsi_session *iscsi ) {
538         struct iscsi_bhs_login_request *request = &iscsi->tx_bhs.login_request;
539         int len;
540
541         /* Construct BHS and initiate transmission */
542         iscsi_start_tx ( iscsi );
543         request->opcode = ( ISCSI_OPCODE_LOGIN_REQUEST |
544                             ISCSI_FLAG_IMMEDIATE );
545         request->flags = ( ( iscsi->status & ISCSI_STATUS_PHASE_MASK ) |
546                            ISCSI_LOGIN_FLAG_TRANSITION );
547         /* version_max and version_min left as zero */
548         len = iscsi_build_login_request_strings ( iscsi, NULL, 0 );
549         ISCSI_SET_LENGTHS ( request->lengths, 0, len );
550         request->isid_iana_en = htonl ( ISCSI_ISID_IANA |
551                                         IANA_EN_FEN_SYSTEMS );
552         /* isid_iana_qual left as zero */
553         request->tsih = htons ( iscsi->tsih );
554         request->itt = htonl ( iscsi->itt );
555         /* cid left as zero */
556         request->cmdsn = htonl ( iscsi->cmdsn );
557         request->expstatsn = htonl ( iscsi->statsn + 1 );
558 }
559
560 /**
561  * Complete iSCSI login request PDU transmission
562  *
563  * @v iscsi             iSCSI session
564  *
565  */
566 static void iscsi_login_request_done ( struct iscsi_session *iscsi ) {
567
568         /* Clear any "strings to send" flags */
569         iscsi->status &= ~ISCSI_STATUS_STRINGS_MASK;
570
571         /* Free any dynamically allocated storage used for login */
572         chap_finish ( &iscsi->chap );
573 }
574
575 /**
576  * Transmit data segment of an iSCSI login request PDU
577  *
578  * @v iscsi             iSCSI session
579  * @ret rc              Return status code
580  *
581  * For login requests, the data segment consists of the login strings.
582  */
583 static int iscsi_tx_login_request ( struct iscsi_session *iscsi ) {
584         struct iscsi_bhs_login_request *request = &iscsi->tx_bhs.login_request;
585         struct io_buffer *iobuf;
586         size_t len;
587
588         len = ISCSI_DATA_LEN ( request->lengths );
589         iobuf = xfer_alloc_iob ( &iscsi->socket, len );
590         if ( ! iobuf )
591                 return -ENOMEM;
592         iob_put ( iobuf, len );
593         iscsi_build_login_request_strings ( iscsi, iobuf->data, len );
594         return xfer_deliver_iob ( &iscsi->socket, iobuf );
595 }
596
597 /**
598  * Handle iSCSI TargetAddress text value
599  *
600  * @v iscsi             iSCSI session
601  * @v value             TargetAddress value
602  * @ret rc              Return status code
603  */
604 static int iscsi_handle_targetaddress_value ( struct iscsi_session *iscsi,
605                                               const char *value ) {
606         char *separator;
607
608         DBGC ( iscsi, "iSCSI %p will redirect to %s\n", iscsi, value );
609
610         /* Replace target address */
611         free ( iscsi->target_address );
612         iscsi->target_address = strdup ( value );
613         if ( ! iscsi->target_address )
614                 return -ENOMEM;
615
616         /* Replace target port */
617         iscsi->target_port = htons ( ISCSI_PORT );
618         separator = strchr ( iscsi->target_address, ':' );
619         if ( separator ) {
620                 *separator = '\0';
621                 iscsi->target_port = strtoul ( ( separator + 1 ), NULL, 0 );
622         }
623
624         return 0;
625 }
626
627 /**
628  * Handle iSCSI AuthMethod text value
629  *
630  * @v iscsi             iSCSI session
631  * @v value             AuthMethod value
632  * @ret rc              Return status code
633  */
634 static int iscsi_handle_authmethod_value ( struct iscsi_session *iscsi,
635                                            const char *value ) {
636
637         /* Mark target as authenticated if no authentication required */
638         if ( ! iscsi->target_username )
639                 iscsi->target_auth_ok = 1;
640
641         /* If server requests CHAP, send the CHAP_A string */
642         if ( strcmp ( value, "CHAP" ) == 0 ) {
643                 DBGC ( iscsi, "iSCSI %p initiating CHAP authentication\n",
644                        iscsi );
645                 iscsi->status |= ISCSI_STATUS_STRINGS_CHAP_ALGORITHM;
646         }
647
648         return 0;
649 }
650
651 /**
652  * Handle iSCSI CHAP_A text value
653  *
654  * @v iscsi             iSCSI session
655  * @v value             CHAP_A value
656  * @ret rc              Return status code
657  */
658 static int iscsi_handle_chap_a_value ( struct iscsi_session *iscsi,
659                                        const char *value ) {
660
661         /* We only ever offer "5" (i.e. MD5) as an algorithm, so if
662          * the server responds with anything else it is a protocol
663          * violation.
664          */
665         if ( strcmp ( value, "5" ) != 0 ) {
666                 DBGC ( iscsi, "iSCSI %p got invalid CHAP algorithm \"%s\"\n",
667                        iscsi, value );
668                 return -EPROTO;
669         }
670
671         return 0;
672 }
673
674 /**
675  * Handle iSCSI CHAP_I text value
676  *
677  * @v iscsi             iSCSI session
678  * @v value             CHAP_I value
679  * @ret rc              Return status code
680  */
681 static int iscsi_handle_chap_i_value ( struct iscsi_session *iscsi,
682                                        const char *value ) {
683         unsigned int identifier;
684         char *endp;
685         int rc;
686
687         /* The CHAP identifier is an integer value */
688         identifier = strtoul ( value, &endp, 0 );
689         if ( *endp != '\0' ) {
690                 DBGC ( iscsi, "iSCSI %p saw invalid CHAP identifier \"%s\"\n",
691                        iscsi, value );
692                 return -EPROTO;
693         }
694
695         /* Prepare for CHAP with MD5 */
696         chap_finish ( &iscsi->chap );
697         if ( ( rc = chap_init ( &iscsi->chap, &md5_algorithm ) ) != 0 ) {
698                 DBGC ( iscsi, "iSCSI %p could not initialise CHAP: %s\n",
699                        iscsi, strerror ( rc ) );
700                 return rc;
701         }
702
703         /* Identifier and secret are the first two components of the
704          * challenge.
705          */
706         chap_set_identifier ( &iscsi->chap, identifier );
707         if ( iscsi->initiator_password ) {
708                 chap_update ( &iscsi->chap, iscsi->initiator_password,
709                               strlen ( iscsi->initiator_password ) );
710         }
711
712         return 0;
713 }
714
715 /**
716  * Handle iSCSI CHAP_C text value
717  *
718  * @v iscsi             iSCSI session
719  * @v value             CHAP_C value
720  * @ret rc              Return status code
721  */
722 static int iscsi_handle_chap_c_value ( struct iscsi_session *iscsi,
723                                        const char *value ) {
724         char buf[3];
725         char *endp;
726         uint8_t byte;
727         unsigned int i;
728
729         /* Check and strip leading "0x" */
730         if ( ( value[0] != '0' ) || ( value[1] != 'x' ) ) {
731                 DBGC ( iscsi, "iSCSI %p saw invalid CHAP challenge \"%s\"\n",
732                        iscsi, value );
733                 return -EPROTO;
734         }
735         value += 2;
736
737         /* Process challenge an octet at a time */
738         for ( ; ( value[0] && value[1] ) ; value += 2 ) {
739                 memcpy ( buf, value, 2 );
740                 buf[2] = 0;
741                 byte = strtoul ( buf, &endp, 16 );
742                 if ( *endp != '\0' ) {
743                         DBGC ( iscsi, "iSCSI %p saw invalid CHAP challenge "
744                                "byte \"%s\"\n", iscsi, buf );
745                         return -EPROTO;
746                 }
747                 chap_update ( &iscsi->chap, &byte, sizeof ( byte ) );
748         }
749
750         /* Build CHAP response */
751         DBGC ( iscsi, "iSCSI %p sending CHAP response\n", iscsi );
752         chap_respond ( &iscsi->chap );
753         iscsi->status |= ISCSI_STATUS_STRINGS_CHAP_RESPONSE;
754
755         /* Send CHAP challenge, if applicable */
756         if ( iscsi->target_username ) {
757                 iscsi->status |= ISCSI_STATUS_STRINGS_CHAP_CHALLENGE;
758                 /* Generate CHAP challenge data */
759                 for ( i = 0 ; i < sizeof ( iscsi->chap_challenge ) ; i++ ) {
760                         iscsi->chap_challenge[i] = random();
761                 }
762         }
763
764         return 0;
765 }
766
767 /**
768  * Handle iSCSI CHAP_N text value
769  *
770  * @v iscsi             iSCSI session
771  * @v value             CHAP_N value
772  * @ret rc              Return status code
773  */
774 static int iscsi_handle_chap_n_value ( struct iscsi_session *iscsi,
775                                        const char *value ) {
776
777         /* The target username isn't actually involved at any point in
778          * the authentication process; it merely serves to identify
779          * which password the target is using to generate the CHAP
780          * response.  We unnecessarily verify that the username is as
781          * expected, in order to provide mildly helpful diagnostics if
782          * the target is supplying the wrong username/password
783          * combination.
784          */
785         if ( iscsi->target_username &&
786              ( strcmp ( iscsi->target_username, value ) != 0 ) ) {
787                 DBGC ( iscsi, "iSCSI %p target username \"%s\" incorrect "
788                        "(wanted \"%s\")\n",
789                        iscsi, value, iscsi->target_username );
790                 return -EACCES;
791         }
792
793         return 0;
794 }
795
796 /**
797  * Handle iSCSI CHAP_R text value
798  *
799  * @v iscsi             iSCSI session
800  * @v value             CHAP_R value
801  * @ret rc              Return status code
802  */
803 static int iscsi_handle_chap_r_value ( struct iscsi_session *iscsi,
804                                        const char *value ) {
805         char buf[3];
806         char *endp;
807         uint8_t byte;
808         unsigned int i;
809         int rc;
810
811         /* Generate CHAP response for verification */
812         chap_finish ( &iscsi->chap );
813         if ( ( rc = chap_init ( &iscsi->chap, &md5_algorithm ) ) != 0 ) {
814                 DBGC ( iscsi, "iSCSI %p could not initialise CHAP: %s\n",
815                        iscsi, strerror ( rc ) );
816                 return rc;
817         }
818         chap_set_identifier ( &iscsi->chap, iscsi->chap_challenge[0] );
819         if ( iscsi->target_password ) {
820                 chap_update ( &iscsi->chap, iscsi->target_password,
821                               strlen ( iscsi->target_password ) );
822         }
823         chap_update ( &iscsi->chap, &iscsi->chap_challenge[1],
824                       ( sizeof ( iscsi->chap_challenge ) - 1 ) );
825         chap_respond ( &iscsi->chap );
826
827         /* Check and strip leading "0x" */
828         if ( ( value[0] != '0' ) || ( value[1] != 'x' ) ) {
829                 DBGC ( iscsi, "iSCSI %p saw invalid CHAP response \"%s\"\n",
830                        iscsi, value );
831                 return -EPROTO;
832         }
833         value += 2;
834
835         /* Check CHAP response length */
836         if ( strlen ( value ) != ( 2 * iscsi->chap.response_len ) ) {
837                 DBGC ( iscsi, "iSCSI %p invalid CHAP response length\n",
838                        iscsi );
839                 return -EPROTO;
840         }
841
842         /* Process response an octet at a time */
843         for ( i = 0 ; ( value[0] && value[1] ) ; value += 2, i++ ) {
844                 memcpy ( buf, value, 2 );
845                 buf[2] = 0;
846                 byte = strtoul ( buf, &endp, 16 );
847                 if ( *endp != '\0' ) {
848                         DBGC ( iscsi, "iSCSI %p saw invalid CHAP response "
849                                "byte \"%s\"\n", iscsi, buf );
850                         return -EPROTO;
851                 }
852                 if ( byte != iscsi->chap.response[i] ) {
853                         DBGC ( iscsi, "iSCSI %p saw incorrect CHAP "
854                                "response\n", iscsi );
855                         return -EACCES;
856                 }
857         }
858         assert ( i == iscsi->chap.response_len );
859
860         /* Mark session as authenticated */
861         iscsi->target_auth_ok = 1;
862
863         return 0;
864 }
865
866 /** An iSCSI text string that we want to handle */
867 struct iscsi_string_type {
868         /** String key
869          *
870          * This is the portion up to and including the "=" sign,
871          * e.g. "InitiatorName=", "CHAP_A=", etc.
872          */
873         const char *key;
874         /** Handle iSCSI string value
875          *
876          * @v iscsi             iSCSI session
877          * @v value             iSCSI string value
878          * @ret rc              Return status code
879          */
880         int ( * handle ) ( struct iscsi_session *iscsi, const char *value );
881 };
882
883 /** iSCSI text strings that we want to handle */
884 static struct iscsi_string_type iscsi_string_types[] = {
885         { "TargetAddress=", iscsi_handle_targetaddress_value },
886         { "AuthMethod=", iscsi_handle_authmethod_value },
887         { "CHAP_A=", iscsi_handle_chap_a_value },
888         { "CHAP_I=", iscsi_handle_chap_i_value },
889         { "CHAP_C=", iscsi_handle_chap_c_value },
890         { "CHAP_N=", iscsi_handle_chap_n_value },
891         { "CHAP_R=", iscsi_handle_chap_r_value },
892         { NULL, NULL }
893 };
894
895 /**
896  * Handle iSCSI string
897  *
898  * @v iscsi             iSCSI session
899  * @v string            iSCSI string (in "key=value" format)
900  * @ret rc              Return status code
901  */
902 static int iscsi_handle_string ( struct iscsi_session *iscsi,
903                                  const char *string ) {
904         struct iscsi_string_type *type;
905         size_t key_len;
906         int rc;
907
908         for ( type = iscsi_string_types ; type->key ; type++ ) {
909                 key_len = strlen ( type->key );
910                 if ( strncmp ( string, type->key, key_len ) != 0 )
911                         continue;
912                 DBGC ( iscsi, "iSCSI %p handling %s\n", iscsi, string );
913                 if ( ( rc = type->handle ( iscsi,
914                                            ( string + key_len ) ) ) != 0 ) {
915                         DBGC ( iscsi, "iSCSI %p could not handle %s: %s\n",
916                                iscsi, string, strerror ( rc ) );
917                         return rc;
918                 }
919                 return 0;
920         }
921         DBGC ( iscsi, "iSCSI %p ignoring %s\n", iscsi, string );
922         return 0;
923 }
924
925 /**
926  * Handle iSCSI strings
927  *
928  * @v iscsi             iSCSI session
929  * @v string            iSCSI string buffer
930  * @v len               Length of string buffer
931  * @ret rc              Return status code
932  */
933 static int iscsi_handle_strings ( struct iscsi_session *iscsi,
934                                   const char *strings, size_t len ) {
935         size_t string_len;
936         int rc;
937
938         /* Handle each string in turn, taking care not to overrun the
939          * data buffer in case of badly-terminated data.
940          */
941         while ( 1 ) {
942                 string_len = ( strnlen ( strings, len ) + 1 );
943                 if ( string_len > len )
944                         break;
945                 if ( ( rc = iscsi_handle_string ( iscsi, strings ) ) != 0 )
946                         return rc;
947                 strings += string_len;
948                 len -= string_len;
949         }
950         return 0;
951 }
952
953 /**
954  * Receive PDU data into buffer
955  *
956  * @v iscsi             iSCSI session
957  * @v data              Data to receive
958  * @v len               Length of data
959  * @ret rc              Return status code
960  *
961  * This can be used when the RX PDU type handler wishes to buffer up
962  * all received data and process the PDU as a single unit.  The caller
963  * is repsonsible for calling iscsi_rx_buffered_data_done() after
964  * processing the data.
965  */
966 static int iscsi_rx_buffered_data ( struct iscsi_session *iscsi,
967                                     const void *data, size_t len ) {
968
969         /* Allocate buffer on first call */
970         if ( ! iscsi->rx_buffer ) {
971                 iscsi->rx_buffer = malloc ( iscsi->rx_len );
972                 if ( ! iscsi->rx_buffer )
973                         return -ENOMEM;
974         }
975
976         /* Copy data to buffer */
977         assert ( ( iscsi->rx_offset + len ) <= iscsi->rx_len );
978         memcpy ( ( iscsi->rx_buffer + iscsi->rx_offset ), data, len );
979
980         return 0;
981 }
982
983 /**
984  * Convert iSCSI response status to return status code
985  *
986  * @v status_class      iSCSI status class
987  * @v status_detail     iSCSI status detail
988  * @ret rc              Return status code
989  */
990 static int iscsi_status_to_rc ( unsigned int status_class,
991                                 unsigned int status_detail ) {
992         switch ( status_class ) {
993         case ISCSI_STATUS_INITIATOR_ERROR :
994                 switch ( status_detail ) {
995                 case ISCSI_STATUS_INITIATOR_ERROR_AUTHENTICATION :
996                         return -EACCES;
997                 case ISCSI_STATUS_INITIATOR_ERROR_AUTHORISATION :
998                         return -EPERM;
999                 case ISCSI_STATUS_INITIATOR_ERROR_NOT_FOUND :
1000                 case ISCSI_STATUS_INITIATOR_ERROR_REMOVED :
1001                         return -ENODEV;
1002                 default :
1003                         return -ENOTSUP;
1004                 }
1005         case ISCSI_STATUS_TARGET_ERROR :
1006                 return -EIO;
1007         default :
1008                 return -EINVAL;
1009         }
1010 }
1011
1012 /**
1013  * Receive data segment of an iSCSI login response PDU
1014  *
1015  * @v iscsi             iSCSI session
1016  * @v data              Received data
1017  * @v len               Length of received data
1018  * @v remaining         Data remaining after this data
1019  * @ret rc              Return status code
1020  */
1021 static int iscsi_rx_login_response ( struct iscsi_session *iscsi,
1022                                      const void *data, size_t len,
1023                                      size_t remaining ) {
1024         struct iscsi_bhs_login_response *response
1025                 = &iscsi->rx_bhs.login_response;
1026         int rc;
1027
1028         /* Buffer up the PDU data */
1029         if ( ( rc = iscsi_rx_buffered_data ( iscsi, data, len ) ) != 0 ) {
1030                 DBGC ( iscsi, "iSCSI %p could not buffer login response: %s\n",
1031                        iscsi, strerror ( rc ) );
1032                 return rc;
1033         }
1034         if ( remaining )
1035                 return 0;
1036
1037         /* Process string data and discard string buffer */
1038         if ( ( rc = iscsi_handle_strings ( iscsi, iscsi->rx_buffer,
1039                                            iscsi->rx_len ) ) != 0 )
1040                 return rc;
1041         iscsi_rx_buffered_data_done ( iscsi );
1042
1043         /* Check for login redirection */
1044         if ( response->status_class == ISCSI_STATUS_REDIRECT ) {
1045                 DBGC ( iscsi, "iSCSI %p redirecting to new server\n", iscsi );
1046                 iscsi_close_connection ( iscsi, 0 );
1047                 if ( ( rc = iscsi_open_connection ( iscsi ) ) != 0 ) {
1048                         DBGC ( iscsi, "iSCSI %p could not redirect: %s\n ",
1049                                iscsi, strerror ( rc ) );
1050                         return rc;
1051                 }
1052                 return 0;
1053         }
1054
1055         /* Check for fatal errors */
1056         if ( response->status_class != 0 ) {
1057                 DBGC ( iscsi, "iSCSI login failure: class %02x detail %02x\n",
1058                        response->status_class, response->status_detail );
1059                 rc = iscsi_status_to_rc ( response->status_class,
1060                                           response->status_detail );
1061                 iscsi->instant_rc = rc;
1062                 return rc;
1063         }
1064
1065         /* Handle login transitions */
1066         if ( response->flags & ISCSI_LOGIN_FLAG_TRANSITION ) {
1067                 switch ( response->flags & ISCSI_LOGIN_NSG_MASK ) {
1068                 case ISCSI_LOGIN_NSG_OPERATIONAL_NEGOTIATION:
1069                         iscsi->status =
1070                                 ( ISCSI_STATUS_OPERATIONAL_NEGOTIATION_PHASE |
1071                                   ISCSI_STATUS_STRINGS_OPERATIONAL );
1072                         break;
1073                 case ISCSI_LOGIN_NSG_FULL_FEATURE_PHASE:
1074                         iscsi->status = ISCSI_STATUS_FULL_FEATURE_PHASE;
1075                         break;
1076                 default:
1077                         DBGC ( iscsi, "iSCSI %p got invalid response flags "
1078                                "%02x\n", iscsi, response->flags );
1079                         return -EIO;
1080                 }
1081         }
1082
1083         /* Send next login request PDU if we haven't reached the full
1084          * feature phase yet.
1085          */
1086         if ( ( iscsi->status & ISCSI_STATUS_PHASE_MASK ) !=
1087              ISCSI_STATUS_FULL_FEATURE_PHASE ) {
1088                 iscsi_start_login ( iscsi );
1089                 return 0;
1090         }
1091
1092         /* Check that target authentication was successful (if required) */
1093         if ( ! iscsi->target_auth_ok ) {
1094                 DBGC ( iscsi, "iSCSI %p nefarious target tried to bypass "
1095                        "authentication\n", iscsi );
1096                 return -EPROTO;
1097         }
1098
1099         /* Reset retry count */
1100         iscsi->retry_count = 0;
1101
1102         /* Record TSIH for future reference */
1103         iscsi->tsih = ntohl ( response->tsih );
1104         
1105         /* Send the actual SCSI command */
1106         iscsi_start_command ( iscsi );
1107
1108         return 0;
1109 }
1110
1111 /****************************************************************************
1112  *
1113  * iSCSI to socket interface
1114  *
1115  */
1116
1117 /**
1118  * Start up a new TX PDU
1119  *
1120  * @v iscsi             iSCSI session
1121  *
1122  * This initiates the process of sending a new PDU.  Only one PDU may
1123  * be in transit at any one time.
1124  */
1125 static void iscsi_start_tx ( struct iscsi_session *iscsi ) {
1126         assert ( iscsi->tx_state == ISCSI_TX_IDLE );
1127         
1128         /* Initialise TX BHS */
1129         memset ( &iscsi->tx_bhs, 0, sizeof ( iscsi->tx_bhs ) );
1130
1131         /* Flag TX engine to start transmitting */
1132         iscsi->tx_state = ISCSI_TX_BHS;
1133 }
1134
1135 /**
1136  * Transmit nothing
1137  *
1138  * @v iscsi             iSCSI session
1139  * @ret rc              Return status code
1140  */
1141 static int iscsi_tx_nothing ( struct iscsi_session *iscsi __unused ) {
1142         return 0;
1143 }
1144
1145 /**
1146  * Transmit basic header segment of an iSCSI PDU
1147  *
1148  * @v iscsi             iSCSI session
1149  * @ret rc              Return status code
1150  */
1151 static int iscsi_tx_bhs ( struct iscsi_session *iscsi ) {
1152         return xfer_deliver_raw ( &iscsi->socket,  &iscsi->tx_bhs,
1153                                   sizeof ( iscsi->tx_bhs ) );
1154 }
1155
1156 /**
1157  * Transmit data segment of an iSCSI PDU
1158  *
1159  * @v iscsi             iSCSI session
1160  * @ret rc              Return status code
1161  * 
1162  * Handle transmission of part of a PDU data segment.  iscsi::tx_bhs
1163  * will be valid when this is called.
1164  */
1165 static int iscsi_tx_data ( struct iscsi_session *iscsi ) {
1166         struct iscsi_bhs_common *common = &iscsi->tx_bhs.common;
1167
1168         switch ( common->opcode & ISCSI_OPCODE_MASK ) {
1169         case ISCSI_OPCODE_DATA_OUT:
1170                 return iscsi_tx_data_out ( iscsi );
1171         case ISCSI_OPCODE_LOGIN_REQUEST:
1172                 return iscsi_tx_login_request ( iscsi );
1173         default:
1174                 /* Nothing to send in other states */
1175                 return 0;
1176         }
1177 }
1178
1179 /**
1180  * Transmit data padding of an iSCSI PDU
1181  *
1182  * @v iscsi             iSCSI session
1183  * @ret rc              Return status code
1184  * 
1185  * Handle transmission of any data padding in a PDU data segment.
1186  * iscsi::tx_bhs will be valid when this is called.
1187  */
1188 static int iscsi_tx_data_padding ( struct iscsi_session *iscsi ) {
1189         static const char pad[] = { '\0', '\0', '\0' };
1190         struct iscsi_bhs_common *common = &iscsi->tx_bhs.common;
1191         size_t pad_len;
1192         
1193         pad_len = ISCSI_DATA_PAD_LEN ( common->lengths );
1194         if ( ! pad_len )
1195                 return 0;
1196
1197         return xfer_deliver_raw ( &iscsi->socket, pad, pad_len );
1198 }
1199
1200 /**
1201  * Complete iSCSI PDU transmission
1202  *
1203  * @v iscsi             iSCSI session
1204  *
1205  * Called when a PDU has been completely transmitted and the TX state
1206  * machine is about to enter the idle state.  iscsi::tx_bhs will be
1207  * valid for the just-completed PDU when this is called.
1208  */
1209 static void iscsi_tx_done ( struct iscsi_session *iscsi ) {
1210         struct iscsi_bhs_common *common = &iscsi->tx_bhs.common;
1211
1212         switch ( common->opcode & ISCSI_OPCODE_MASK ) {
1213         case ISCSI_OPCODE_DATA_OUT:
1214                 iscsi_data_out_done ( iscsi );
1215         case ISCSI_OPCODE_LOGIN_REQUEST:
1216                 iscsi_login_request_done ( iscsi );
1217         default:
1218                 /* No action */
1219                 break;
1220         }
1221 }
1222
1223 /**
1224  * Transmit iSCSI PDU
1225  *
1226  * @v iscsi             iSCSI session
1227  * @v buf               Temporary data buffer
1228  * @v len               Length of temporary data buffer
1229  * 
1230  * Constructs data to be sent for the current TX state
1231  */
1232 static void iscsi_tx_step ( struct process *process ) {
1233         struct iscsi_session *iscsi =
1234                 container_of ( process, struct iscsi_session, process );
1235         struct iscsi_bhs_common *common = &iscsi->tx_bhs.common;
1236         int ( * tx ) ( struct iscsi_session *iscsi );
1237         enum iscsi_tx_state next_state;
1238         size_t tx_len;
1239         int rc;
1240
1241         /* Select fragment to transmit */
1242         while ( 1 ) {
1243                 switch ( iscsi->tx_state ) {
1244                 case ISCSI_TX_IDLE:
1245                         /* Stop processing */
1246                         return;
1247                 case ISCSI_TX_BHS:
1248                         tx = iscsi_tx_bhs;
1249                         tx_len = sizeof ( iscsi->tx_bhs );
1250                         next_state = ISCSI_TX_AHS;
1251                         break;
1252                 case ISCSI_TX_AHS:
1253                         tx = iscsi_tx_nothing;
1254                         tx_len = 0;
1255                         next_state = ISCSI_TX_DATA;
1256                         break;
1257                 case ISCSI_TX_DATA:
1258                         tx = iscsi_tx_data;
1259                         tx_len = ISCSI_DATA_LEN ( common->lengths );
1260                         next_state = ISCSI_TX_DATA_PADDING;
1261                         break;
1262                 case ISCSI_TX_DATA_PADDING:
1263                         tx = iscsi_tx_data_padding;
1264                         tx_len = ISCSI_DATA_PAD_LEN ( common->lengths );
1265                         next_state = ISCSI_TX_IDLE;
1266                         break;
1267                 default:
1268                         assert ( 0 );
1269                         return;
1270                 }
1271
1272                 /* Check for window availability, if needed */
1273                 if ( tx_len && ( xfer_window ( &iscsi->socket ) == 0 ) ) {
1274                         /* Cannot transmit at this point; stop processing */
1275                         return;
1276                 }
1277
1278                 /* Transmit data */
1279                 if ( ( rc = tx ( iscsi ) ) != 0 ) {
1280                         DBGC ( iscsi, "iSCSI %p could not transmit: %s\n",
1281                                iscsi, strerror ( rc ) );
1282                         return;
1283                 }
1284
1285                 /* Move to next state */
1286                 iscsi->tx_state = next_state;
1287                 if ( next_state == ISCSI_TX_IDLE )
1288                         iscsi_tx_done ( iscsi );
1289         }
1290 }
1291
1292 /**
1293  * Receive basic header segment of an iSCSI PDU
1294  *
1295  * @v iscsi             iSCSI session
1296  * @v data              Received data
1297  * @v len               Length of received data
1298  * @v remaining         Data remaining after this data
1299  * @ret rc              Return status code
1300  *
1301  * This fills in iscsi::rx_bhs with the data from the BHS portion of
1302  * the received PDU.
1303  */
1304 static int iscsi_rx_bhs ( struct iscsi_session *iscsi, const void *data,
1305                           size_t len, size_t remaining __unused ) {
1306         memcpy ( &iscsi->rx_bhs.bytes[iscsi->rx_offset], data, len );
1307         if ( ( iscsi->rx_offset + len ) >= sizeof ( iscsi->rx_bhs ) ) {
1308                 DBGC2 ( iscsi, "iSCSI %p received PDU opcode %#x len %#lx\n",
1309                         iscsi, iscsi->rx_bhs.common.opcode,
1310                         ISCSI_DATA_LEN ( iscsi->rx_bhs.common.lengths ) );
1311         }
1312         return 0;
1313 }
1314
1315 /**
1316  * Discard portion of an iSCSI PDU.
1317  *
1318  * @v iscsi             iSCSI session
1319  * @v data              Received data
1320  * @v len               Length of received data
1321  * @v remaining         Data remaining after this data
1322  * @ret rc              Return status code
1323  *
1324  * This discards data from a portion of a received PDU.
1325  */
1326 static int iscsi_rx_discard ( struct iscsi_session *iscsi __unused,
1327                               const void *data __unused, size_t len __unused,
1328                               size_t remaining __unused ) {
1329         /* Do nothing */
1330         return 0;
1331 }
1332
1333 /**
1334  * Receive data segment of an iSCSI PDU
1335  *
1336  * @v iscsi             iSCSI session
1337  * @v data              Received data
1338  * @v len               Length of received data
1339  * @v remaining         Data remaining after this data
1340  * @ret rc              Return status code
1341  *
1342  * Handle processing of part of a PDU data segment.  iscsi::rx_bhs
1343  * will be valid when this is called.
1344  */
1345 static int iscsi_rx_data ( struct iscsi_session *iscsi, const void *data,
1346                            size_t len, size_t remaining ) {
1347         struct iscsi_bhs_common_response *response
1348                 = &iscsi->rx_bhs.common_response;
1349
1350         /* Update cmdsn and statsn */
1351         iscsi->cmdsn = ntohl ( response->expcmdsn );
1352         iscsi->statsn = ntohl ( response->statsn );
1353
1354         switch ( response->opcode & ISCSI_OPCODE_MASK ) {
1355         case ISCSI_OPCODE_LOGIN_RESPONSE:
1356                 return iscsi_rx_login_response ( iscsi, data, len, remaining );
1357         case ISCSI_OPCODE_SCSI_RESPONSE:
1358                 return iscsi_rx_scsi_response ( iscsi, data, len, remaining );
1359         case ISCSI_OPCODE_DATA_IN:
1360                 return iscsi_rx_data_in ( iscsi, data, len, remaining );
1361         case ISCSI_OPCODE_R2T:
1362                 return iscsi_rx_r2t ( iscsi, data, len, remaining );
1363         default:
1364                 if ( remaining )
1365                         return 0;
1366                 DBGC ( iscsi, "iSCSI %p unknown opcode %02x\n", iscsi,
1367                        response->opcode );
1368                 return -ENOTSUP;
1369         }
1370 }
1371
1372 /**
1373  * Receive new data
1374  *
1375  * @v socket            Transport layer interface
1376  * @v data              Received data
1377  * @v len               Length of received data
1378  * @ret rc              Return status code
1379  *
1380  * This handles received PDUs.  The receive strategy is to fill in
1381  * iscsi::rx_bhs with the contents of the BHS portion of the PDU,
1382  * throw away any AHS portion, and then process each part of the data
1383  * portion as it arrives.  The data processing routine therefore
1384  * always has a full copy of the BHS available, even for portions of
1385  * the data in different packets to the BHS.
1386  */
1387 static int iscsi_socket_deliver_raw ( struct xfer_interface *socket,
1388                                       const void *data, size_t len ) {
1389         struct iscsi_session *iscsi =
1390                 container_of ( socket, struct iscsi_session, socket );
1391         struct iscsi_bhs_common *common = &iscsi->rx_bhs.common;
1392         int ( * rx ) ( struct iscsi_session *iscsi, const void *data,
1393                        size_t len, size_t remaining );
1394         enum iscsi_rx_state next_state;
1395         size_t frag_len;
1396         size_t remaining;
1397         int rc;
1398
1399         while ( 1 ) {
1400                 switch ( iscsi->rx_state ) {
1401                 case ISCSI_RX_BHS:
1402                         rx = iscsi_rx_bhs;
1403                         iscsi->rx_len = sizeof ( iscsi->rx_bhs );
1404                         next_state = ISCSI_RX_AHS;                      
1405                         break;
1406                 case ISCSI_RX_AHS:
1407                         rx = iscsi_rx_discard;
1408                         iscsi->rx_len = 4 * ISCSI_AHS_LEN ( common->lengths );
1409                         next_state = ISCSI_RX_DATA;
1410                         break;
1411                 case ISCSI_RX_DATA:
1412                         rx = iscsi_rx_data;
1413                         iscsi->rx_len = ISCSI_DATA_LEN ( common->lengths );
1414                         next_state = ISCSI_RX_DATA_PADDING;
1415                         break;
1416                 case ISCSI_RX_DATA_PADDING:
1417                         rx = iscsi_rx_discard;
1418                         iscsi->rx_len = ISCSI_DATA_PAD_LEN ( common->lengths );
1419                         next_state = ISCSI_RX_BHS;
1420                         break;
1421                 default:
1422                         assert ( 0 );
1423                         return -EINVAL;
1424                 }
1425
1426                 frag_len = iscsi->rx_len - iscsi->rx_offset;
1427                 if ( frag_len > len )
1428                         frag_len = len;
1429                 remaining = iscsi->rx_len - iscsi->rx_offset - frag_len;
1430                 if ( ( rc = rx ( iscsi, data, frag_len, remaining ) ) != 0 ) {
1431                         DBGC ( iscsi, "iSCSI %p could not process received "
1432                                "data: %s\n", iscsi, strerror ( rc ) );
1433                         iscsi_close_connection ( iscsi, rc );
1434                         iscsi_scsi_done ( iscsi, rc );
1435                         return rc;
1436                 }
1437
1438                 iscsi->rx_offset += frag_len;
1439                 data += frag_len;
1440                 len -= frag_len;
1441
1442                 /* If all the data for this state has not yet been
1443                  * received, stay in this state for now.
1444                  */
1445                 if ( iscsi->rx_offset != iscsi->rx_len )
1446                         return 0;
1447
1448                 iscsi->rx_state = next_state;
1449                 iscsi->rx_offset = 0;
1450         }
1451
1452         return 0;
1453 }
1454
1455 /**
1456  * Handle stream connection closure
1457  *
1458  * @v socket            Transport layer interface
1459  * @v rc                Reason for close
1460  *
1461  */
1462 static void iscsi_socket_close ( struct xfer_interface *socket, int rc ) {
1463         struct iscsi_session *iscsi =
1464                 container_of ( socket, struct iscsi_session, socket );
1465
1466         /* Even a graceful close counts as an error for iSCSI */
1467         if ( ! rc )
1468                 rc = -ECONNRESET;
1469
1470         /* Close session cleanly */
1471         iscsi_close_connection ( iscsi, rc );
1472
1473         /* Retry connection if within the retry limit, otherwise fail */
1474         if ( ++iscsi->retry_count <= ISCSI_MAX_RETRIES ) {
1475                 DBGC ( iscsi, "iSCSI %p retrying connection (retry #%d)\n",
1476                        iscsi, iscsi->retry_count );
1477                 if ( ( rc = iscsi_open_connection ( iscsi ) ) != 0 ) {
1478                         DBGC ( iscsi, "iSCSI %p could not reconnect: %s\n",
1479                                iscsi, strerror ( rc ) );
1480                         iscsi_scsi_done ( iscsi, rc );
1481                 }
1482         } else {
1483                 DBGC ( iscsi, "iSCSI %p retry count exceeded\n", iscsi );
1484                 iscsi->instant_rc = rc;
1485                 iscsi_scsi_done ( iscsi, rc );
1486         }
1487 }
1488
1489 /**
1490  * Handle redirection event
1491  *
1492  * @v socket            Transport layer interface
1493  * @v type              Location type
1494  * @v args              Remaining arguments depend upon location type
1495  * @ret rc              Return status code
1496  */
1497 static int iscsi_vredirect ( struct xfer_interface *socket, int type,
1498                              va_list args ) {
1499         struct iscsi_session *iscsi =
1500                 container_of ( socket, struct iscsi_session, socket );
1501         va_list tmp;
1502         struct sockaddr *peer;
1503
1504         /* Intercept redirects to a LOCATION_SOCKET and record the IP
1505          * address for the iBFT.  This is a bit of a hack, but avoids
1506          * inventing an ioctl()-style call to retrieve the socket
1507          * address from a data-xfer interface.
1508          */
1509         if ( type == LOCATION_SOCKET ) {
1510                 va_copy ( tmp, args );
1511                 ( void ) va_arg ( tmp, int ); /* Discard "semantics" */
1512                 peer = va_arg ( tmp, struct sockaddr * );
1513                 memcpy ( &iscsi->target_sockaddr, peer,
1514                          sizeof ( iscsi->target_sockaddr ) );
1515                 va_end ( tmp );
1516         }
1517
1518         return xfer_vopen ( socket, type, args );
1519 }
1520                              
1521
1522 /** iSCSI socket operations */
1523 static struct xfer_interface_operations iscsi_socket_operations = {
1524         .close          = iscsi_socket_close,
1525         .vredirect      = iscsi_vredirect,
1526         .window         = unlimited_xfer_window,
1527         .alloc_iob      = default_xfer_alloc_iob,
1528         .deliver_iob    = xfer_deliver_as_raw,
1529         .deliver_raw    = iscsi_socket_deliver_raw,
1530 };
1531
1532
1533 /****************************************************************************
1534  *
1535  * iSCSI command issuing
1536  *
1537  */
1538
1539 /**
1540  * Issue SCSI command
1541  *
1542  * @v scsi              SCSI device
1543  * @v command           SCSI command
1544  * @ret rc              Return status code
1545  */
1546 static int iscsi_command ( struct scsi_device *scsi,
1547                            struct scsi_command *command ) {
1548         struct iscsi_session *iscsi =
1549                 container_of ( scsi->backend, struct iscsi_session, refcnt );
1550         int rc;
1551
1552         /* Record SCSI command */
1553         iscsi->command = command;
1554
1555         /* Abort immediately if we have a recorded permanent failure */
1556         if ( iscsi->instant_rc ) {
1557                 rc = iscsi->instant_rc;
1558                 goto done;
1559         }
1560
1561         /* Issue command or open connection as appropriate */
1562         if ( iscsi->status ) {
1563                 iscsi_start_command ( iscsi );
1564         } else {
1565                 if ( ( rc = iscsi_open_connection ( iscsi ) ) != 0 )
1566                         goto done;
1567         }
1568
1569         /* Wait for command to complete */
1570         iscsi->rc = -EINPROGRESS;
1571         while ( iscsi->rc == -EINPROGRESS )
1572                 step();
1573         rc = iscsi->rc;
1574
1575  done:
1576         iscsi->command = NULL;
1577         return rc;
1578 }
1579
1580 static int iscsi_detached_command ( struct scsi_device *scsi __unused,
1581                                     struct scsi_command *command __unused ) {
1582         return -ENODEV;
1583 }
1584
1585 /**
1586  * Shut down iSCSI interface
1587  *
1588  * @v scsi              SCSI device
1589  */
1590 void iscsi_detach ( struct scsi_device *scsi ) {
1591         struct iscsi_session *iscsi =
1592                 container_of ( scsi->backend, struct iscsi_session, refcnt );
1593
1594         xfer_nullify ( &iscsi->socket );
1595         iscsi_close_connection ( iscsi, 0 );
1596         process_del ( &iscsi->process );
1597         scsi->command = iscsi_detached_command;
1598         ref_put ( scsi->backend );
1599         scsi->backend = NULL;
1600 }
1601
1602 /****************************************************************************
1603  *
1604  * Instantiator
1605  *
1606  */
1607
1608 /** iSCSI root path components (as per RFC4173) */
1609 enum iscsi_root_path_component {
1610         RP_LITERAL = 0,
1611         RP_SERVERNAME,
1612         RP_PROTOCOL,
1613         RP_PORT,
1614         RP_LUN,
1615         RP_TARGETNAME,
1616         NUM_RP_COMPONENTS
1617 };
1618
1619 /**
1620  * Parse iSCSI LUN
1621  *
1622  * @v iscsi             iSCSI session
1623  * @v lun_string        LUN string representation (as per RFC4173)
1624  * @ret rc              Return status code
1625  */
1626 static int iscsi_parse_lun ( struct iscsi_session *iscsi,
1627                              const char *lun_string ) {
1628         char *p = ( char * ) lun_string;
1629         union {
1630                 uint64_t u64;
1631                 uint16_t u16[4];
1632         } lun;
1633         int i;
1634
1635         /* Empty LUN; assume LUN 0 */
1636         if ( ! *lun_string )
1637                 return 0;
1638
1639         for ( i = 0 ; i < 4 ; i++ ) {
1640                 lun.u16[i] = strtoul ( p, &p, 16 );
1641                 if ( *p != '-' )
1642                         return -EINVAL;
1643                 p++;
1644         }
1645         if ( *p )
1646                 return -EINVAL;
1647
1648         iscsi->lun = lun.u64;
1649         return 0;
1650 }
1651
1652 /**
1653  * Parse iSCSI root path
1654  *
1655  * @v iscsi             iSCSI session
1656  * @v root_path         iSCSI root path (as per RFC4173)
1657  * @ret rc              Return status code
1658  */
1659 static int iscsi_parse_root_path ( struct iscsi_session *iscsi,
1660                                    const char *root_path ) {
1661         char rp_copy[ strlen ( root_path ) + 1 ];
1662         char *rp_comp[NUM_RP_COMPONENTS];
1663         char *rp = rp_copy;
1664         int i = 0;
1665         int rc;
1666
1667         /* Split root path into component parts */
1668         strcpy ( rp_copy, root_path );
1669         while ( 1 ) {
1670                 rp_comp[i++] = rp;
1671                 if ( i == NUM_RP_COMPONENTS )
1672                         break;
1673                 for ( ; *rp != ':' ; rp++ ) {
1674                         if ( ! *rp ) {
1675                                 DBGC ( iscsi, "iSCSI %p root path \"%s\" "
1676                                        "too short\n", iscsi, root_path );
1677                                 return -EINVAL;
1678                         }
1679                 }
1680                 *(rp++) = '\0';
1681         }
1682
1683         /* Use root path components to configure iSCSI session */
1684         iscsi->target_address = strdup ( rp_comp[RP_SERVERNAME] );
1685         if ( ! iscsi->target_address )
1686                 return -ENOMEM;
1687         iscsi->target_port = strtoul ( rp_comp[RP_PORT], NULL, 10 );
1688         if ( ! iscsi->target_port )
1689                 iscsi->target_port = ISCSI_PORT;
1690         if ( ( rc = iscsi_parse_lun ( iscsi, rp_comp[RP_LUN] ) ) != 0 ) {
1691                 DBGC ( iscsi, "iSCSI %p invalid LUN \"%s\"\n",
1692                        iscsi, rp_comp[RP_LUN] );
1693                 return rc;
1694         }
1695         iscsi->target_iqn = strdup ( rp_comp[RP_TARGETNAME] );
1696         if ( ! iscsi->target_iqn )
1697                 return -ENOMEM;
1698
1699         return 0;
1700 }
1701
1702 /**
1703  * Set iSCSI authentication details
1704  *
1705  * @v iscsi             iSCSI session
1706  * @v initiator_username Initiator username, if any
1707  * @v initiator_password Initiator password, if any
1708  * @v target_username   Target username, if any
1709  * @v target_password   Target password, if any
1710  * @ret rc              Return status code
1711  */
1712 static int iscsi_set_auth ( struct iscsi_session *iscsi,
1713                             const char *initiator_username,
1714                             const char *initiator_password,
1715                             const char *target_username,
1716                             const char *target_password ) {
1717
1718         /* Check for initiator or target credentials */
1719         if ( initiator_username || initiator_password ||
1720              target_username || target_password ) {
1721
1722                 /* We must have at least an initiator username+password */
1723                 if ( ! ( initiator_username && initiator_password ) )
1724                         goto invalid_auth;
1725
1726                 /* Store initiator credentials */
1727                 iscsi->initiator_username = strdup ( initiator_username );
1728                 if ( ! iscsi->initiator_username )
1729                         return -ENOMEM;
1730                 iscsi->initiator_password = strdup ( initiator_password );
1731                 if ( ! iscsi->initiator_password )
1732                         return -ENOMEM;
1733
1734                 /* Check for target credentials */
1735                 if ( target_username || target_password ) {
1736
1737                         /* We must have target username+password */
1738                         if ( ! ( target_username && target_password ) )
1739                                 goto invalid_auth;
1740
1741                         /* Store target credentials */
1742                         iscsi->target_username = strdup ( target_username );
1743                         if ( ! iscsi->target_username )
1744                                 return -ENOMEM;
1745                         iscsi->target_password = strdup ( target_password );
1746                         if ( ! iscsi->target_password )
1747                                 return -ENOMEM;
1748                 }
1749         }
1750
1751         return 0;
1752
1753  invalid_auth:
1754         DBGC ( iscsi, "iSCSI %p invalid credentials: initiator "
1755                "%sname,%spw, target %sname,%spw\n", iscsi,
1756                ( initiator_username ? "" : "no " ),
1757                ( initiator_password ? "" : "no " ),
1758                ( target_username ? "" : "no " ),
1759                ( target_password ? "" : "no " ) );
1760         return -EINVAL;
1761 }
1762
1763 /**
1764  * Attach iSCSI interface
1765  *
1766  * @v scsi              SCSI device
1767  * @v root_path         iSCSI root path (as per RFC4173)
1768  * @ret rc              Return status code
1769  */
1770 int iscsi_attach ( struct scsi_device *scsi, const char *root_path ) {
1771         struct iscsi_session *iscsi;
1772         int rc;
1773
1774         /* Allocate and initialise structure */
1775         iscsi = zalloc ( sizeof ( *iscsi ) );
1776         if ( ! iscsi )
1777                 return -ENOMEM;
1778         iscsi->refcnt.free = iscsi_free;
1779         xfer_init ( &iscsi->socket, &iscsi_socket_operations, &iscsi->refcnt );
1780         process_init ( &iscsi->process, iscsi_tx_step, &iscsi->refcnt );
1781
1782         /* Parse root path */
1783         if ( ( rc = iscsi_parse_root_path ( iscsi, root_path ) ) != 0 )
1784                 goto err;
1785         /* Set fields not specified by root path */
1786         if ( ( rc = iscsi_set_auth ( iscsi,
1787                                      iscsi_initiator_username,
1788                                      iscsi_initiator_password,
1789                                      iscsi_target_username,
1790                                      iscsi_target_password ) ) != 0 )
1791                 goto err;
1792
1793         /* Sanity checks */
1794         if ( ! iscsi->target_address ) {
1795                 DBGC ( iscsi, "iSCSI %p does not yet support discovery\n",
1796                        iscsi );
1797                 rc = -ENOTSUP;
1798                 goto err;
1799         }
1800         if ( ! iscsi->target_iqn ) {
1801                 DBGC ( iscsi, "iSCSI %p no target address supplied in %s\n",
1802                        iscsi, root_path );
1803                 rc = -EINVAL;
1804                 goto err;
1805         }
1806
1807         /* Attach parent interface, mortalise self, and return */
1808         scsi->backend = ref_get ( &iscsi->refcnt );
1809         scsi->command = iscsi_command;
1810         scsi->lun = iscsi->lun;
1811         ref_put ( &iscsi->refcnt );
1812         return 0;
1813         
1814  err:
1815         ref_put ( &iscsi->refcnt );
1816         return rc;
1817 }
1818
1819 /****************************************************************************
1820  *
1821  * Settings
1822  *
1823  */
1824
1825 /** iSCSI initiator IQN setting */
1826 struct setting initiator_iqn_setting __setting = {
1827         .name = "initiator-iqn",
1828         .description = "iSCSI initiator name",
1829         .tag = DHCP_ISCSI_INITIATOR_IQN,
1830         .type = &setting_type_string,
1831 };
1832
1833 /** iSCSI reverse username setting */
1834 struct setting reverse_username_setting __setting = {
1835         .name = "reverse-username",
1836         .description = "Reverse user name",
1837         .tag = DHCP_EB_REVERSE_USERNAME,
1838         .type = &setting_type_string,
1839 };
1840
1841 /** iSCSI reverse password setting */
1842 struct setting reverse_password_setting __setting = {
1843         .name = "reverse-password",
1844         .description = "Reverse password",
1845         .tag = DHCP_EB_REVERSE_PASSWORD,
1846         .type = &setting_type_string,
1847 };
1848
1849 /** An iSCSI string setting */
1850 struct iscsi_string_setting {
1851         /** Setting */
1852         struct setting *setting;
1853         /** String to update */
1854         char **string;
1855         /** String prefix */
1856         const char *prefix;
1857 };
1858
1859 /** iSCSI string settings */
1860 static struct iscsi_string_setting iscsi_string_settings[] = {
1861         {
1862                 .setting = &initiator_iqn_setting,
1863                 .string = &iscsi_explicit_initiator_iqn,
1864                 .prefix = "",
1865         },
1866         {
1867                 .setting = &username_setting,
1868                 .string = &iscsi_initiator_username,
1869                 .prefix = "",
1870         },
1871         {
1872                 .setting = &password_setting,
1873                 .string = &iscsi_initiator_password,
1874                 .prefix = "",
1875         },
1876         {
1877                 .setting = &reverse_username_setting,
1878                 .string = &iscsi_target_username,
1879                 .prefix = "",
1880         },
1881         {
1882                 .setting = &reverse_password_setting,
1883                 .string = &iscsi_target_password,
1884                 .prefix = "",
1885         },
1886         {
1887                 .setting = &hostname_setting,
1888                 .string = &iscsi_default_initiator_iqn,
1889                 .prefix = "iqn.2000-01.org.etherboot:",
1890         },
1891 };
1892
1893 /**
1894  * Apply iSCSI setting
1895  *
1896  * @v setting           iSCSI string setting
1897  * @ret rc              Return status code
1898  */
1899 static int apply_iscsi_string_setting ( struct iscsi_string_setting *setting ){
1900         size_t prefix_len;
1901         int setting_len;
1902         size_t len;
1903         int check_len;
1904         char *p;
1905
1906         /* Free old string */
1907         free ( *setting->string );
1908         *setting->string = NULL;
1909
1910         /* Allocate new string */
1911         prefix_len = strlen ( setting->prefix );
1912         setting_len = fetch_setting_len ( NULL, setting->setting );
1913         if ( setting_len < 0 ) {
1914                 /* Missing settings are not errors; leave strings as NULL */
1915                 return 0;
1916         }
1917         len = ( prefix_len + setting_len + 1 );
1918         p = *setting->string = malloc ( len );
1919         if ( ! p )
1920                 return -ENOMEM;
1921
1922         /* Fill new string */
1923         strcpy ( p, setting->prefix );
1924         check_len = fetch_string_setting ( NULL, setting->setting,
1925                                            ( p + prefix_len ),
1926                                            ( len - prefix_len ) );
1927         assert ( check_len == setting_len );
1928
1929         return 0;
1930 }
1931
1932 /**
1933  * Apply iSCSI settings
1934  *
1935  * @ret rc              Return status code
1936  */
1937 static int apply_iscsi_settings ( void ) {
1938         struct iscsi_string_setting *setting;
1939         unsigned int i;
1940         int rc;
1941
1942         for ( i = 0 ; i < ( sizeof ( iscsi_string_settings ) /
1943                             sizeof ( iscsi_string_settings[0] ) ) ; i++ ) {
1944                 setting = &iscsi_string_settings[i];
1945                 if ( ( rc = apply_iscsi_string_setting ( setting ) ) != 0 ) {
1946                         DBG ( "iSCSI could not apply setting %s\n",
1947                               setting->setting->name );
1948                         return rc;
1949                 }
1950         }
1951
1952         return 0;
1953 }
1954
1955 /** iSCSI settings applicator */
1956 struct settings_applicator iscsi_settings_applicator __settings_applicator = {
1957         .apply = apply_iscsi_settings,
1958 };
1959
1960 /****************************************************************************
1961  *
1962  * Initiator name
1963  *
1964  */
1965
1966 /**
1967  * Get iSCSI initiator IQN
1968  *
1969  * @v iscsi             iSCSI session
1970  * @ret rc              Return status code
1971  */
1972 const char * iscsi_initiator_iqn ( void ) {
1973
1974         if ( iscsi_explicit_initiator_iqn )
1975                 return iscsi_explicit_initiator_iqn;
1976         if ( iscsi_default_initiator_iqn )
1977                 return iscsi_default_initiator_iqn;
1978         return "iqn.2000-09.org.etherboot:UNKNOWN";
1979 }