![[BACK]](/icons/cvsweb/back.gif){kind=icon}
Return to istgt_lu_ctl.c CVS log ![[TXT]](/icons/cvsweb/text.gif){kind=icon}
![[DIR]](/icons/cvsweb/dir.gif){kind=icon}
Up to [ELWIX - Embedded LightWeight unIX -] / embedaddon / istgt / src|
Return to istgt_lu_ctl.c CVS log | Up to [ELWIX - Embedded LightWeight unIX -] / embedaddon / istgt / src |
1.1 misho 1: /*
2: * Copyright (C) 2008-2011 Daisuke Aoyama <aoyama@peach.ne.jp>.
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 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 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: #ifdef HAVE_CONFIG_H
29: #include "config.h"
30: #endif
31:
32: #include <inttypes.h>
33: #include <stdint.h>
34:
35: #include <stdarg.h>
36: #include <stdio.h>
37: #include <stdlib.h>
38: #include <string.h>
39: #include <pthread.h>
40: #ifdef HAVE_PTHREAD_NP_H
41: #include <pthread_np.h>
42: #endif
43: #include <unistd.h>
44: #include <sys/param.h>
45:
46: #include "istgt.h"
47: #include "istgt_ver.h"
48: #include "istgt_log.h"
49: #include "istgt_sock.h"
50: #include "istgt_misc.h"
51: #include "istgt_md5.h"
52: #include "istgt_lu.h"
53: #include "istgt_iscsi.h"
54: #include "istgt_proto.h"
55:
56: #define TIMEOUT_RW 60
57: #define MAX_LINEBUF 4096
58:
59: typedef struct istgt_uctl_t {
60: int id;
61:
62: ISTGT_Ptr istgt;
63: PORTAL portal;
64: int sock;
65: pthread_t thread;
66:
67: int family;
68: char caddr[MAX_ADDRBUF];
69: char saddr[MAX_ADDRBUF];
70:
71: ISTGT_CHAP_AUTH auth;
72: int authenticated;
73:
74: int timeout;
75: int auth_group;
76: int no_auth;
77: int req_auth;
78: int req_mutual;
79:
80: char *mediadirectory;
81:
82: int recvtmpsize;
83: int recvtmpcnt;
84: int recvtmpidx;
85: int recvbufsize;
86: int sendbufsize;
87: int worksize;
88: char recvtmp[MAX_LINEBUF];
89: char recvbuf[MAX_LINEBUF];
90: char sendbuf[MAX_LINEBUF];
91: char work[MAX_LINEBUF];
92: char *cmd;
93: char *arg;
94: } UCTL;
95: typedef UCTL *UCTL_Ptr;
96:
97: typedef enum {
98: UCTL_CMD_OK = 0,
99: UCTL_CMD_ERR = 1,
100: UCTL_CMD_EOF = 2,
101: UCTL_CMD_QUIT = 3,
102: UCTL_CMD_DISCON = 4,
103: } UCTL_CMD_STATUS;
104:
105: #define ARGS_DELIM " \t"
106:
107: static int
108: istgt_uctl_readline(UCTL_Ptr uctl)
109: {
110: ssize_t total;
111:
112: total = istgt_readline_socket(uctl->sock, uctl->recvbuf, uctl->recvbufsize,
113: uctl->recvtmp, uctl->recvtmpsize,
114: &uctl->recvtmpidx, &uctl->recvtmpcnt,
115: uctl->timeout);
116: if (total < 0) {
117: return UCTL_CMD_DISCON;
118: }
119: if (total == 0) {
120: return UCTL_CMD_EOF;
121: }
122: return UCTL_CMD_OK;
123: }
124:
125: static int
126: istgt_uctl_writeline(UCTL_Ptr uctl)
127: {
128: ssize_t total;
129: ssize_t expect;
130:
131: expect = strlen(uctl->sendbuf);
132: total = istgt_writeline_socket(uctl->sock, uctl->sendbuf, uctl->timeout);
133: if (total < 0) {
134: return UCTL_CMD_DISCON;
135: }
136: if (total != expect) {
137: return UCTL_CMD_ERR;
138: }
139: return UCTL_CMD_OK;
140: }
141:
142: static int
143: istgt_uctl_snprintf(UCTL_Ptr uctl, const char *format, ...)
144: {
145: va_list ap;
146: int rc;
147:
148: va_start(ap, format);
149: rc = vsnprintf(uctl->sendbuf, uctl->sendbufsize, format, ap);
150: va_end(ap);
151: return rc;
152: }
153:
154: static int
155: istgt_uctl_get_media_present(ISTGT_LU_Ptr lu, int lun)
156: {
157: int rc;
158:
159: switch (lu->type) {
160: case ISTGT_LU_TYPE_DVD:
161: MTX_LOCK(&lu->mutex);
162: rc = istgt_lu_dvd_media_present(lu->lun[lun].spec);
163: MTX_UNLOCK(&lu->mutex);
164: break;
165: case ISTGT_LU_TYPE_TAPE:
166: MTX_LOCK(&lu->mutex);
167: rc = istgt_lu_tape_media_present(lu->lun[lun].spec);
168: MTX_UNLOCK(&lu->mutex);
169: break;
170: default:
171: rc = 0;
172: }
173: return rc;
174: }
175:
176: static int
177: istgt_uctl_get_media_lock(ISTGT_LU_Ptr lu, int lun)
178: {
179: int rc;
180:
181: switch (lu->type) {
182: case ISTGT_LU_TYPE_DVD:
183: MTX_LOCK(&lu->mutex);
184: rc = istgt_lu_dvd_media_lock(lu->lun[lun].spec);
185: MTX_UNLOCK(&lu->mutex);
186: break;
187: case ISTGT_LU_TYPE_TAPE:
188: MTX_LOCK(&lu->mutex);
189: rc = istgt_lu_tape_media_lock(lu->lun[lun].spec);
190: MTX_UNLOCK(&lu->mutex);
191: break;
192: default:
193: rc = 0;
194: }
195: return rc;
196: }
197:
198: static int
199: istgt_uctl_get_authinfo(UCTL_Ptr uctl, const char *authuser)
200: {
201: char *authfile = NULL;
202: int ag_tag;
203: int rc;
204:
205: ag_tag = uctl->auth_group;
206: ISTGT_TRACELOG(ISTGT_TRACE_DEBUG, "ag_tag=%d\n", ag_tag);
207:
208: MTX_LOCK(&uctl->istgt->mutex);
209: authfile = xstrdup(uctl->istgt->authfile);
210: MTX_UNLOCK(&uctl->istgt->mutex);
211:
212: rc = istgt_chap_get_authinfo(&uctl->auth, authfile, authuser, ag_tag);
213: if (rc < 0) {
214: ISTGT_ERRLOG("chap_get_authinfo() failed\n");
215: xfree(authfile);
216: return -1;
217: }
218: xfree(authfile);
219: return 0;
220: }
221:
222: static int
223: istgt_uctl_cmd_auth(UCTL_Ptr uctl)
224: {
225: const char *delim = ARGS_DELIM;
226: char *arg;
227: char *label;
228: char *chap_a;
229: char *chap_i;
230: char *chap_c;
231: char *chap_n;
232: char *chap_r;
233: int rc;
234:
235: arg = uctl->arg;
236: label = strsepq(&arg, delim);
237:
238: if (label == NULL) {
239: istgt_uctl_snprintf(uctl, "ERR invalid parameters\n");
240: rc = istgt_uctl_writeline(uctl);
241: if (rc != UCTL_CMD_OK) {
242: return rc;
243: }
244: return UCTL_CMD_ERR;
245: }
246:
247: if (strcasecmp(label, "CHAP_A") == 0) {
248: if (uctl->auth.chap_phase != ISTGT_CHAP_PHASE_WAIT_A) {
249: istgt_uctl_snprintf(uctl, "ERR CHAP sequence error\n");
250: error_return:
251: uctl->auth.chap_phase = ISTGT_CHAP_PHASE_WAIT_A;
252: rc = istgt_uctl_writeline(uctl);
253: if (rc != UCTL_CMD_OK) {
254: return rc;
255: }
256: return UCTL_CMD_ERR;
257: }
258:
259: chap_a = strsepq(&arg, delim);
260: if (chap_a == NULL || strcasecmp(chap_a, "5") != 0) {
261: istgt_uctl_snprintf(uctl, "ERR invalid algorithm\n");
262: goto error_return;
263: }
264:
265: /* Identifier is one octet */
266: istgt_gen_random(uctl->auth.chap_id, 1);
267: /* Challenge Value is a variable stream of octets */
268: /* (binary length MUST not exceed 1024 bytes) */
269: uctl->auth.chap_challenge_len = ISTGT_CHAP_CHALLENGE_LEN;
270: istgt_gen_random(uctl->auth.chap_challenge,
271: uctl->auth.chap_challenge_len);
272:
273: istgt_bin2hex(uctl->work, uctl->worksize,
274: uctl->auth.chap_challenge,
275: uctl->auth.chap_challenge_len);
276:
277: istgt_uctl_snprintf(uctl, "%s CHAP_IC %d %s\n",
278: uctl->cmd, (int) uctl->auth.chap_id[0],
279: uctl->work);
280:
281: rc = istgt_uctl_writeline(uctl);
282: if (rc != UCTL_CMD_OK) {
283: return rc;
284: }
285: uctl->auth.chap_phase = ISTGT_CHAP_PHASE_WAIT_NR;
286: /* 3-way handshake */
287: return UCTL_CMD_OK;
288: } else if (strcasecmp(label, "CHAP_NR") == 0) {
289: uint8_t resmd5[ISTGT_MD5DIGEST_LEN];
290: uint8_t tgtmd5[ISTGT_MD5DIGEST_LEN];
291: ISTGT_MD5CTX md5ctx;
292:
293: if (uctl->auth.chap_phase != ISTGT_CHAP_PHASE_WAIT_NR) {
294: istgt_uctl_snprintf(uctl, "ERR CHAP sequence error\n");
295: goto error_return;
296: }
297:
298: chap_n = strsepq(&arg, delim);
299: chap_r = strsepq(&arg, delim);
300: if (chap_n == NULL || chap_r == NULL) {
301: istgt_uctl_snprintf(uctl, "ERR no response\n");
302: goto error_return;
303: }
304: //ISTGT_TRACELOG(ISTGT_TRACE_DEBUG, "N=%s, R=%s\n", chap_n, chap_r);
305:
306: rc = istgt_hex2bin(resmd5, ISTGT_MD5DIGEST_LEN, chap_r);
307: if (rc < 0 || rc != ISTGT_MD5DIGEST_LEN) {
308: istgt_uctl_snprintf(uctl, "ERR response format error\n");
309: goto error_return;
310: }
311:
312: rc = istgt_uctl_get_authinfo(uctl, chap_n);
313: if (rc < 0) {
314: ISTGT_ERRLOG("auth failed (user %.64s)\n", chap_n);
315: istgt_uctl_snprintf(uctl, "ERR auth user or secret is missing\n");
316: goto error_return;
317: }
318: if (uctl->auth.user == NULL || uctl->auth.secret == NULL) {
319: ISTGT_ERRLOG("auth failed (user %.64s)\n", chap_n);
320: istgt_uctl_snprintf(uctl, "ERR auth user or secret is missing\n");
321: goto error_return;
322: }
323:
324: istgt_md5init(&md5ctx);
325: /* Identifier */
326: istgt_md5update(&md5ctx, uctl->auth.chap_id, 1);
327: /* followed by secret */
328: istgt_md5update(&md5ctx, uctl->auth.secret,
329: strlen(uctl->auth.secret));
330: /* followed by Challenge Value */
331: istgt_md5update(&md5ctx, uctl->auth.chap_challenge,
332: uctl->auth.chap_challenge_len);
333: /* tgtmd5 is expecting Response Value */
334: istgt_md5final(tgtmd5, &md5ctx);
335:
336: /* compare MD5 digest */
337: if (memcmp(tgtmd5, resmd5, ISTGT_MD5DIGEST_LEN) != 0) {
338: /* not match */
339: ISTGT_ERRLOG("auth failed (user %.64s)\n", chap_n);
340: istgt_uctl_snprintf(uctl, "ERR auth user or secret is missing\n");
341: goto error_return;
342: }
343: /* OK client's secret */
344: uctl->authenticated = 1;
345:
346: /* mutual CHAP? */
347: chap_i = strsepq(&arg, delim);
348: chap_c = strsepq(&arg, delim);
349: if (chap_i != NULL && chap_c != NULL) {
350: /* Identifier */
351: uctl->auth.chap_mid[0] = (uint8_t) strtol(chap_i, NULL, 10);
352: /* Challenge Value */
353: rc = istgt_hex2bin(uctl->auth.chap_mchallenge,
354: ISTGT_CHAP_CHALLENGE_LEN, chap_c);
355: if (rc < 0) {
356: istgt_uctl_snprintf(uctl, "ERR challenge format error\n");
357: goto error_return;
358: }
359: uctl->auth.chap_mchallenge_len = rc;
360:
361: if (uctl->auth.muser == NULL || uctl->auth.msecret == NULL) {
362: ISTGT_ERRLOG("auth failed (user %.64s)\n", chap_n);
363: istgt_uctl_snprintf(uctl,
364: "ERR auth user or secret is missing\n");
365: goto error_return;
366: }
367:
368: istgt_md5init(&md5ctx);
369: /* Identifier */
370: istgt_md5update(&md5ctx, uctl->auth.chap_mid, 1);
371: /* followed by secret */
372: istgt_md5update(&md5ctx, uctl->auth.msecret,
373: strlen(uctl->auth.msecret));
374: /* followed by Challenge Value */
375: istgt_md5update(&md5ctx, uctl->auth.chap_mchallenge,
376: uctl->auth.chap_mchallenge_len);
377: /* tgtmd5 is Response Value */
378: istgt_md5final(tgtmd5, &md5ctx);
379:
380: istgt_bin2hex(uctl->work, uctl->worksize,
381: tgtmd5, ISTGT_MD5DIGEST_LEN);
382:
383: /* send NR for mutual CHAP */
384: istgt_uctl_snprintf(uctl, "%s CHAP_NR \"%s\" %s\n",
385: uctl->cmd,
386: uctl->auth.muser,
387: uctl->work);
388: rc = istgt_uctl_writeline(uctl);
389: if (rc != UCTL_CMD_OK) {
390: return rc;
391: }
392: } else {
393: /* not mutual */
394: if (uctl->req_mutual) {
395: ISTGT_ERRLOG("required mutual CHAP\n");
396: istgt_uctl_snprintf(uctl, "ERR CHAP sequence error\n");
397: goto error_return;
398: }
399: }
400:
401: uctl->auth.chap_phase = ISTGT_CHAP_PHASE_END;
402: } else {
403: istgt_uctl_snprintf(uctl, "ERR CHAP sequence error\n");
404: goto error_return;
405: }
406:
407: /* auth succeeded (but mutual may fail) */
408: istgt_uctl_snprintf(uctl, "OK %s\n", uctl->cmd);
409: rc = istgt_uctl_writeline(uctl);
410: if (rc != UCTL_CMD_OK) {
411: return rc;
412: }
413: return UCTL_CMD_OK;
414: }
415:
416: static int
417: istgt_uctl_cmd_quit(UCTL_Ptr uctl)
418: {
419: int rc;
420:
421: istgt_uctl_snprintf(uctl, "OK %s\n", uctl->cmd);
422: rc = istgt_uctl_writeline(uctl);
423: if (rc != UCTL_CMD_OK) {
424: return rc;
425: }
426: return UCTL_CMD_QUIT;
427: }
428:
429: static int
430: istgt_uctl_cmd_noop(UCTL_Ptr uctl)
431: {
432: int rc;
433:
434: istgt_uctl_snprintf(uctl, "OK %s\n", uctl->cmd);
435: rc = istgt_uctl_writeline(uctl);
436: if (rc != UCTL_CMD_OK) {
437: return rc;
438: }
439: return UCTL_CMD_OK;
440: }
441:
442: static int
443: istgt_uctl_cmd_version(UCTL_Ptr uctl)
444: {
445: int rc;
446:
447: istgt_uctl_snprintf(uctl, "%s %s (%s)\n", uctl->cmd,
448: ISTGT_VERSION, ISTGT_EXTRA_VERSION);
449: rc = istgt_uctl_writeline(uctl);
450: if (rc != UCTL_CMD_OK) {
451: return rc;
452: }
453:
454: /* version succeeded */
455: istgt_uctl_snprintf(uctl, "OK %s\n", uctl->cmd);
456: rc = istgt_uctl_writeline(uctl);
457: if (rc != UCTL_CMD_OK) {
458: return rc;
459: }
460: return UCTL_CMD_OK;
461: }
462:
463: static int
464: istgt_uctl_cmd_list(UCTL_Ptr uctl)
465: {
466: ISTGT_LU_Ptr lu;
467: ISTGT_LU_LUN_Ptr llp;
468: const char *delim = ARGS_DELIM;
469: char *arg;
470: char *iqn;
471: char *lun;
472: char *mflags;
473: char *mfile;
474: char *msize;
475: char *mtype;
476: char *workp;
477: int lun_i;
478: int worksize;
479: int present;
480: int lock;
481: int rc;
482: int i;
483:
484: arg = uctl->arg;
485: iqn = strsepq(&arg, delim);
486: lun = strsepq(&arg, delim);
487:
488: if (arg != NULL) {
489: istgt_uctl_snprintf(uctl, "ERR invalid parameters\n");
490: rc = istgt_uctl_writeline(uctl);
491: if (rc != UCTL_CMD_OK) {
492: return rc;
493: }
494: return UCTL_CMD_ERR;
495: }
496:
497: if (iqn == NULL) {
498: /* all targets */
499: MTX_LOCK(&uctl->istgt->mutex);
500: for (i = 0; i < MAX_LOGICAL_UNIT; i++) {
501: lu = uctl->istgt->logical_unit[i];
502: if (lu == NULL)
503: continue;
504: istgt_uctl_snprintf(uctl, "%s %s\n", uctl->cmd, lu->name);
505: rc = istgt_uctl_writeline(uctl);
506: if (rc != UCTL_CMD_OK) {
507: MTX_UNLOCK(&uctl->istgt->mutex);
508: return rc;
509: }
510: }
511: MTX_UNLOCK(&uctl->istgt->mutex);
512: } else {
513: /* specified target */
514: MTX_LOCK(&uctl->istgt->mutex);
515: if (lun == NULL) {
516: lun_i = 0;
517: } else {
518: lun_i = (int) strtol(lun, NULL, 10);
519: }
520: lu = istgt_lu_find_target(uctl->istgt, iqn);
521: if (lu == NULL) {
522: MTX_UNLOCK(&uctl->istgt->mutex);
523: istgt_uctl_snprintf(uctl, "ERR no target\n");
524: error_return:
525: rc = istgt_uctl_writeline(uctl);
526: if (rc != UCTL_CMD_OK) {
527: return rc;
528: }
529: return UCTL_CMD_ERR;
530: }
531: if (lun_i < 0 || lun_i >= lu->maxlun) {
532: MTX_UNLOCK(&uctl->istgt->mutex);
533: istgt_uctl_snprintf(uctl, "ERR no target\n");
534: goto error_return;
535: }
536: llp = &lu->lun[lun_i];
537:
538: worksize = uctl->worksize;
539: workp = uctl->work;
540:
541: switch (llp->type) {
542: case ISTGT_LU_LUN_TYPE_REMOVABLE:
543: mflags = istgt_lu_get_media_flags_string(llp->u.removable.flags,
544: workp, worksize);
545: worksize -= strlen(mflags) + 1;
546: workp += strlen(mflags) + 1;
547: present = istgt_uctl_get_media_present(lu, lun_i);
548: lock = istgt_uctl_get_media_lock(lu, lun_i);
549: mfile = llp->u.removable.file;
550: if (llp->u.removable.flags & ISTGT_LU_FLAG_MEDIA_AUTOSIZE) {
551: snprintf(workp, worksize, "auto");
552: } else {
553: snprintf(workp, worksize, "%"PRIu64,
554: llp->u.removable.size);
555: }
556: msize = workp;
557: worksize -= strlen(msize) + 1;
558: workp += strlen(msize) + 1;
559: snprintf(workp, worksize, "-");
560: mtype = workp;
561: worksize -= strlen(msize) + 1;
562: workp += strlen(msize) + 1;
563:
564: istgt_uctl_snprintf(uctl, "%s lun%u %s %s %s %s %s \"%s\" %s\n",
565: uctl->cmd, lun_i,
566: "removable",
567: (present ? "present" : "absent"),
568: (lock ? "lock" : "unlock"),
569: mtype, mflags, mfile, msize);
570: rc = istgt_uctl_writeline(uctl);
571: break;
572: case ISTGT_LU_LUN_TYPE_STORAGE:
573: mfile = llp->u.storage.file;
574: snprintf(workp, worksize, "%"PRIu64,
575: llp->u.storage.size);
576: msize = workp;
577: worksize -= strlen(msize) + 1;
578: workp += strlen(msize) + 1;
579:
580: istgt_uctl_snprintf(uctl, "%s lun%u %s \"%s\" %s\n",
581: uctl->cmd, lun_i,
582: "storage",
583: mfile, msize);
584: rc = istgt_uctl_writeline(uctl);
585: break;
586: case ISTGT_LU_LUN_TYPE_DEVICE:
587: mfile = llp->u.device.file;
588:
589: istgt_uctl_snprintf(uctl, "%s lun%u %s \"%s\"\n",
590: uctl->cmd, lun_i,
591: "device",
592: mfile);
593: rc = istgt_uctl_writeline(uctl);
594: break;
595: case ISTGT_LU_LUN_TYPE_SLOT:
596: default:
597: MTX_UNLOCK(&uctl->istgt->mutex);
598: istgt_uctl_snprintf(uctl, "ERR unsupport LUN type\n");
599: goto error_return;
600: }
601:
602: if (rc != UCTL_CMD_OK) {
603: MTX_UNLOCK(&uctl->istgt->mutex);
604: return rc;
605: }
606: MTX_UNLOCK(&uctl->istgt->mutex);
607: }
608:
609: /* list succeeded */
610: istgt_uctl_snprintf(uctl, "OK %s\n", uctl->cmd);
611: rc = istgt_uctl_writeline(uctl);
612: if (rc != UCTL_CMD_OK) {
613: return rc;
614: }
615: return UCTL_CMD_OK;
616: }
617:
618: static int
619: istgt_uctl_cmd_unload(UCTL_Ptr uctl)
620: {
621: ISTGT_LU_Ptr lu;
622: ISTGT_LU_LUN_Ptr llp;
623: const char *delim = ARGS_DELIM;
624: char *arg;
625: char *iqn;
626: char *lun;
627: int lun_i;
628: int rc;
629:
630: arg = uctl->arg;
631: iqn = strsepq(&arg, delim);
632: lun = strsepq(&arg, delim);
633:
634: if (iqn == NULL || arg != NULL) {
635: istgt_uctl_snprintf(uctl, "ERR invalid parameters\n");
636: rc = istgt_uctl_writeline(uctl);
637: if (rc != UCTL_CMD_OK) {
638: return rc;
639: }
640: return UCTL_CMD_ERR;
641: }
642:
643: if (lun == NULL) {
644: lun_i = 0;
645: } else {
646: lun_i = (int) strtol(lun, NULL, 10);
647: }
648: lu = istgt_lu_find_target(uctl->istgt, iqn);
649: if (lu == NULL) {
650: istgt_uctl_snprintf(uctl, "ERR no target\n");
651: error_return:
652: rc = istgt_uctl_writeline(uctl);
653: if (rc != UCTL_CMD_OK) {
654: return rc;
655: }
656: return UCTL_CMD_ERR;
657: }
658: if (lun_i < 0 || lun_i >= lu->maxlun) {
659: istgt_uctl_snprintf(uctl, "ERR no target\n");
660: goto error_return;
661: }
662: llp = &lu->lun[lun_i];
663: if (llp->type != ISTGT_LU_LUN_TYPE_REMOVABLE) {
664: istgt_uctl_snprintf(uctl, "ERR not removable\n");
665: goto error_return;
666: }
667:
668: /* unload media from lun */
669: switch (lu->type) {
670: case ISTGT_LU_TYPE_DVD:
671: MTX_LOCK(&lu->mutex);
672: rc = istgt_lu_dvd_unload_media(lu->lun[lun_i].spec);
673: MTX_UNLOCK(&lu->mutex);
674: break;
675: case ISTGT_LU_TYPE_TAPE:
676: MTX_LOCK(&lu->mutex);
677: rc = istgt_lu_tape_unload_media(lu->lun[lun_i].spec);
678: MTX_UNLOCK(&lu->mutex);
679: break;
680: default:
681: rc = -1;
682: }
683:
684: if (rc < 0) {
685: istgt_uctl_snprintf(uctl, "ERR unload\n");
686: rc = istgt_uctl_writeline(uctl);
687: if (rc != UCTL_CMD_OK) {
688: return rc;
689: }
690: return UCTL_CMD_ERR;
691: }
692:
693: /* logging event */
694: ISTGT_NOTICELOG("Media Unload %s lun%d from %s\n",
695: iqn, lun_i, uctl->caddr);
696:
697: /* unload succeeded */
698: istgt_uctl_snprintf(uctl, "OK %s\n", uctl->cmd);
699: rc = istgt_uctl_writeline(uctl);
700: if (rc != UCTL_CMD_OK) {
701: return rc;
702: }
703: return UCTL_CMD_OK;
704: }
705:
706: static int
707: istgt_uctl_cmd_load(UCTL_Ptr uctl)
708: {
709: ISTGT_LU_Ptr lu;
710: ISTGT_LU_LUN_Ptr llp;
711: const char *delim = ARGS_DELIM;
712: char *arg;
713: char *iqn;
714: char *lun;
715: int lun_i;
716: int rc;
717:
718: arg = uctl->arg;
719: iqn = strsepq(&arg, delim);
720: lun = strsepq(&arg, delim);
721:
722: if (iqn == NULL || arg != NULL) {
723: istgt_uctl_snprintf(uctl, "ERR invalid parameters\n");
724: rc = istgt_uctl_writeline(uctl);
725: if (rc != UCTL_CMD_OK) {
726: return rc;
727: }
728: return UCTL_CMD_ERR;
729: }
730:
731: if (lun == NULL) {
732: lun_i = 0;
733: } else {
734: lun_i = (int) strtol(lun, NULL, 10);
735: }
736: lu = istgt_lu_find_target(uctl->istgt, iqn);
737: if (lu == NULL) {
738: istgt_uctl_snprintf(uctl, "ERR no target\n");
739: error_return:
740: rc = istgt_uctl_writeline(uctl);
741: if (rc != UCTL_CMD_OK) {
742: return rc;
743: }
744: return UCTL_CMD_ERR;
745: }
746: if (lun_i < 0 || lun_i >= lu->maxlun) {
747: istgt_uctl_snprintf(uctl, "ERR no target\n");
748: goto error_return;
749: }
750: llp = &lu->lun[lun_i];
751: if (llp->type != ISTGT_LU_LUN_TYPE_REMOVABLE) {
752: istgt_uctl_snprintf(uctl, "ERR not removable\n");
753: goto error_return;
754: }
755:
756: /* load media to lun */
757: switch (lu->type) {
758: case ISTGT_LU_TYPE_DVD:
759: MTX_LOCK(&lu->mutex);
760: rc = istgt_lu_dvd_load_media(lu->lun[lun_i].spec);
761: MTX_UNLOCK(&lu->mutex);
762: break;
763: case ISTGT_LU_TYPE_TAPE:
764: MTX_LOCK(&lu->mutex);
765: rc = istgt_lu_tape_load_media(lu->lun[lun_i].spec);
766: MTX_UNLOCK(&lu->mutex);
767: break;
768: default:
769: rc = -1;
770: }
771:
772: if (rc < 0) {
773: istgt_uctl_snprintf(uctl, "ERR load\n");
774: rc = istgt_uctl_writeline(uctl);
775: if (rc != UCTL_CMD_OK) {
776: return rc;
777: }
778: return UCTL_CMD_ERR;
779: }
780:
781: /* logging event */
782: ISTGT_NOTICELOG("Media Load %s lun%d from %s\n",
783: iqn, lun_i, uctl->caddr);
784:
785: /* load succeeded */
786: istgt_uctl_snprintf(uctl, "OK %s\n", uctl->cmd);
787: rc = istgt_uctl_writeline(uctl);
788: if (rc != UCTL_CMD_OK) {
789: return rc;
790: }
791: return UCTL_CMD_OK;
792: }
793:
794: static int
795: istgt_uctl_cmd_change(UCTL_Ptr uctl)
796: {
797: ISTGT_LU_Ptr lu;
798: ISTGT_LU_LUN_Ptr llp;
799: const char *delim = ARGS_DELIM;
800: char empty_flags[] = "ro";
801: char empty_size[] = "0";
802: char *arg;
803: char *iqn;
804: char *lun;
805: char *type;
806: char *flags;
807: char *file;
808: char *size;
809: char *safedir;
810: char *fullpath;
811: char *abspath;
812: int lun_i;
813: int len;
814: int rc;
815:
816: arg = uctl->arg;
817: iqn = strsepq(&arg, delim);
818: lun = strsepq(&arg, delim);
819:
820: type = strsepq(&arg, delim);
821: flags = strsepq(&arg, delim);
822: file = strsepq(&arg, delim);
823: size = strsepq(&arg, delim);
824:
825: if (iqn == NULL || lun == NULL || type == NULL || flags == NULL
826: || file == NULL || size == NULL || arg != NULL) {
827: istgt_uctl_snprintf(uctl, "ERR invalid parameters\n");
828: rc = istgt_uctl_writeline(uctl);
829: if (rc != UCTL_CMD_OK) {
830: return rc;
831: }
832: return UCTL_CMD_ERR;
833: }
834:
835: if (lun == NULL) {
836: lun_i = 0;
837: } else {
838: lun_i = (int) strtol(lun, NULL, 10);
839: }
840: lu = istgt_lu_find_target(uctl->istgt, iqn);
841: if (lu == NULL) {
842: istgt_uctl_snprintf(uctl, "ERR no target\n");
843: error_return:
844: rc = istgt_uctl_writeline(uctl);
845: if (rc != UCTL_CMD_OK) {
846: return rc;
847: }
848: return UCTL_CMD_ERR;
849: }
850: if (lun_i < 0 || lun_i >= lu->maxlun) {
851: istgt_uctl_snprintf(uctl, "ERR no target\n");
852: goto error_return;
853: }
854: llp = &lu->lun[lun_i];
855: if (llp->type != ISTGT_LU_LUN_TYPE_REMOVABLE) {
856: istgt_uctl_snprintf(uctl, "ERR not removable\n");
857: goto error_return;
858: }
859:
860: /* make safe directory (start '/', end '/') */
861: len = 1 + strlen(uctl->mediadirectory) + 1 + 1;
862: safedir = xmalloc(len);
863: if (uctl->mediadirectory[0] != '/') {
864: ISTGT_WARNLOG("MediaDirectory is not starting with '/'\n");
865: snprintf(safedir, len, "/%s", uctl->mediadirectory);
866: } else {
867: snprintf(safedir, len, "%s", uctl->mediadirectory);
868: }
869: if (strlen(safedir) > 1 && safedir[strlen(safedir) - 1] != '/') {
870: safedir[strlen(safedir) + 1] = '\0';
871: safedir[strlen(safedir)] = '/';
872: }
873:
874: /* check abspath in mediadirectory? */
875: len = strlen(safedir) + strlen(file) + 1;
876: fullpath = xmalloc(len);
877: if (file[0] != '/') {
878: snprintf(fullpath, len, "%s%s", safedir, file);
879: } else {
880: snprintf(fullpath, len, "%s", file);
881: }
882: #ifdef PATH_MAX
883: abspath = xmalloc(len + PATH_MAX);
884: file = realpath(fullpath, abspath);
885: #else
886: /*
887: {
888: long path_max;
889: path_max = pathconf(fullpath, _PC_PATH_MAX);
890: if (path_max != -1L) {
891: abspath = xmalloc(path_max);
892: file = realpath(fullpath, abspath);
893: }
894: }
895: */
896: file = abspath = realpath(fullpath, NULL);
897: #endif /* PATH_MAX */
898: if (file == NULL) {
899: ISTGT_ERRLOG("realpath(%s) failed\n", fullpath);
900: internal_error:
901: xfree(safedir);
902: xfree(fullpath);
903: xfree(abspath);
904: istgt_uctl_snprintf(uctl, "ERR %s internal error\n", uctl->cmd);
905: rc = istgt_uctl_writeline(uctl);
906: if (rc != UCTL_CMD_OK) {
907: return rc;
908: }
909: return UCTL_CMD_ERR;
910: }
911: if (strcasecmp(file, "/dev/null") == 0) {
912: /* OK, empty slot */
913: flags = empty_flags;
914: size = empty_size;
915: } else if (strncasecmp(file, safedir, strlen(safedir)) != 0) {
916: ISTGT_ERRLOG("Realpath(%s) is not within MediaDirectory(%s)\n",
917: file, safedir);
918: goto internal_error;
919: }
920:
921: /* unload and load media from lun */
922: switch (lu->type) {
923: case ISTGT_LU_TYPE_DVD:
924: MTX_LOCK(&lu->mutex);
925: rc = istgt_lu_dvd_change_media(lu->lun[lun_i].spec,
926: type, flags, file, size);
927: MTX_UNLOCK(&lu->mutex);
928: break;
929: case ISTGT_LU_TYPE_TAPE:
930: MTX_LOCK(&lu->mutex);
931: rc = istgt_lu_tape_change_media(lu->lun[lun_i].spec,
932: type, flags, file, size);
933: MTX_UNLOCK(&lu->mutex);
934: break;
935: default:
936: rc = -1;
937: }
938:
939: if (rc < 0) {
940: xfree(safedir);
941: xfree(fullpath);
942: xfree(abspath);
943: istgt_uctl_snprintf(uctl, "ERR change\n");
944: rc = istgt_uctl_writeline(uctl);
945: if (rc != UCTL_CMD_OK) {
946: return rc;
947: }
948: return UCTL_CMD_ERR;
949: }
950:
951: /* logging event */
952: ISTGT_NOTICELOG("Media Change \"%s %s %s %s\" on %s lun%d from %s\n",
953: type, flags, file, size, iqn, lun_i, uctl->caddr);
954:
955: xfree(safedir);
956: xfree(fullpath);
957: xfree(abspath);
958:
959: /* change succeeded */
960: istgt_uctl_snprintf(uctl, "OK %s\n", uctl->cmd);
961: rc = istgt_uctl_writeline(uctl);
962: if (rc != UCTL_CMD_OK) {
963: return rc;
964: }
965: return UCTL_CMD_OK;
966: }
967:
968: static int
969: istgt_uctl_cmd_reset(UCTL_Ptr uctl)
970: {
971: ISTGT_LU_Ptr lu;
972: ISTGT_LU_LUN_Ptr llp;
973: const char *delim = ARGS_DELIM;
974: char *arg;
975: char *iqn;
976: char *lun;
977: int lun_i;
978: int rc;
979:
980: arg = uctl->arg;
981: iqn = strsepq(&arg, delim);
982: lun = strsepq(&arg, delim);
983:
984: if (iqn == NULL || arg != NULL) {
985: istgt_uctl_snprintf(uctl, "ERR invalid parameters\n");
986: rc = istgt_uctl_writeline(uctl);
987: if (rc != UCTL_CMD_OK) {
988: return rc;
989: }
990: return UCTL_CMD_ERR;
991: }
992:
993: if (lun == NULL) {
994: lun_i = 0;
995: } else {
996: lun_i = (int) strtol(lun, NULL, 10);
997: }
998: lu = istgt_lu_find_target(uctl->istgt, iqn);
999: if (lu == NULL) {
1000: istgt_uctl_snprintf(uctl, "ERR no target\n");
1001: error_return:
1002: rc = istgt_uctl_writeline(uctl);
1003: if (rc != UCTL_CMD_OK) {
1004: return rc;
1005: }
1006: return UCTL_CMD_ERR;
1007: }
1008: if (lun_i < 0 || lun_i >= lu->maxlun) {
1009: istgt_uctl_snprintf(uctl, "ERR no target\n");
1010: goto error_return;
1011: }
1012: llp = &lu->lun[lun_i];
1013:
1014: /* reset lun */
1015: switch (lu->type) {
1016: case ISTGT_LU_TYPE_DISK:
1017: MTX_LOCK(&lu->mutex);
1018: rc = istgt_lu_disk_reset(lu, lun_i);
1019: MTX_UNLOCK(&lu->mutex);
1020: break;
1021: case ISTGT_LU_TYPE_DVD:
1022: MTX_LOCK(&lu->mutex);
1023: rc = istgt_lu_dvd_reset(lu, lun_i);
1024: MTX_UNLOCK(&lu->mutex);
1025: break;
1026: case ISTGT_LU_TYPE_TAPE:
1027: MTX_LOCK(&lu->mutex);
1028: rc = istgt_lu_tape_reset(lu, lun_i);
1029: MTX_UNLOCK(&lu->mutex);
1030: break;
1031: case ISTGT_LU_TYPE_NONE:
1032: case ISTGT_LU_TYPE_PASS:
1033: rc = -1;
1034: break;
1035: default:
1036: rc = -1;
1037: }
1038:
1039: if (rc < 0) {
1040: istgt_uctl_snprintf(uctl, "ERR reset\n");
1041: rc = istgt_uctl_writeline(uctl);
1042: if (rc != UCTL_CMD_OK) {
1043: return rc;
1044: }
1045: return UCTL_CMD_ERR;
1046: }
1047:
1048: /* logging event */
1049: ISTGT_NOTICELOG("Unit Reset %s lun%d from %s\n",
1050: iqn, lun_i, uctl->caddr);
1051:
1052: /* reset succeeded */
1053: istgt_uctl_snprintf(uctl, "OK %s\n", uctl->cmd);
1054: rc = istgt_uctl_writeline(uctl);
1055: if (rc != UCTL_CMD_OK) {
1056: return rc;
1057: }
1058: return UCTL_CMD_OK;
1059: }
1060:
1061: static int
1062: istgt_uctl_cmd_info(UCTL_Ptr uctl)
1063: {
1064: ISTGT_LU_Ptr lu;
1065: CONN_Ptr conn;
1066: SESS_Ptr sess;
1067: const char *delim = ARGS_DELIM;
1068: char *arg;
1069: char *iqn;
1070: int ncount;
1071: int rc;
1072: int i, j, k;
1073:
1074: arg = uctl->arg;
1075: iqn = strsepq(&arg, delim);
1076:
1077: if (arg != NULL) {
1078: istgt_uctl_snprintf(uctl, "ERR invalid parameters\n");
1079: rc = istgt_uctl_writeline(uctl);
1080: if (rc != UCTL_CMD_OK) {
1081: return rc;
1082: }
1083: return UCTL_CMD_ERR;
1084: }
1085:
1086: ncount = 0;
1087: MTX_LOCK(&uctl->istgt->mutex);
1088: for (i = 0; i < MAX_LOGICAL_UNIT; i++) {
1089: lu = uctl->istgt->logical_unit[i];
1090: if (lu == NULL)
1091: continue;
1092: if (iqn != NULL && strcasecmp(iqn, lu->name) != 0)
1093: continue;
1094:
1095: istgt_lock_gconns();
1096: MTX_LOCK(&lu->mutex);
1097: for (j = 1; j < MAX_LU_TSIH; j++) {
1098: if (lu->tsih[j].initiator_port != NULL
1099: && lu->tsih[j].tsih != 0) {
1100: conn = istgt_find_conn(lu->tsih[j].initiator_port,
1101: lu->name, lu->tsih[j].tsih);
1102: if (conn == NULL || conn->sess == NULL)
1103: continue;
1104:
1105: sess = conn->sess;
1106: MTX_LOCK(&sess->mutex);
1107: for (k = 0; k < sess->connections; k++) {
1108: conn = sess->conns[k];
1109: if (conn == NULL)
1110: continue;
1111:
1112: istgt_uctl_snprintf(uctl, "%s Login from %s (%s) on %s LU%d"
1113: " (%s:%s,%d), ISID=%"PRIx64", TSIH=%u,"
1114: " CID=%u, HeaderDigest=%s, DataDigest=%s,"
1115: " MaxConnections=%u,"
1116: " FirstBurstLength=%u, MaxBurstLength=%u,"
1117: " MaxRecvDataSegmentLength=%u,"
1118: " InitialR2T=%s, ImmediateData=%s\n",
1119: uctl->cmd,
1120: conn->initiator_name,
1121: conn->initiator_addr,
1122: conn->target_name, lu->num,
1123: conn->portal.host, conn->portal.port,
1124: conn->portal.tag,
1125: conn->sess->isid, conn->sess->tsih,
1126: conn->cid,
1127: (conn->header_digest ? "on" : "off"),
1128: (conn->data_digest ? "on" : "off"),
1129: conn->sess->MaxConnections,
1130: conn->sess->FirstBurstLength,
1131: conn->sess->MaxBurstLength,
1132: conn->MaxRecvDataSegmentLength,
1133: (conn->sess->initial_r2t ? "Yes" : "No"),
1134: (conn->sess->immediate_data ? "Yes" : "No"));
1135: rc = istgt_uctl_writeline(uctl);
1136: if (rc != UCTL_CMD_OK) {
1137: MTX_UNLOCK(&sess->mutex);
1138: MTX_UNLOCK(&lu->mutex);
1139: istgt_unlock_gconns();
1140: MTX_UNLOCK(&uctl->istgt->mutex);
1141: return rc;
1142: }
1143: ncount++;
1144: }
1145: MTX_UNLOCK(&sess->mutex);
1146: }
1147: }
1148: MTX_UNLOCK(&lu->mutex);
1149: istgt_unlock_gconns();
1150: }
1151: MTX_UNLOCK(&uctl->istgt->mutex);
1152: if (ncount == 0) {
1153: istgt_uctl_snprintf(uctl, "%s no login\n", uctl->cmd);
1154: rc = istgt_uctl_writeline(uctl);
1155: if (rc != UCTL_CMD_OK) {
1156: return rc;
1157: }
1158: }
1159:
1160: /* info succeeded */
1161: istgt_uctl_snprintf(uctl, "OK %s\n", uctl->cmd);
1162: rc = istgt_uctl_writeline(uctl);
1163: if (rc != UCTL_CMD_OK) {
1164: return rc;
1165: }
1166: return UCTL_CMD_OK;
1167: }
1168:
1169:
1170: typedef struct istgt_uctl_cmd_table_t
1171: {
1172: const char *name;
1173: int (*func) (UCTL_Ptr uctl);
1174: } ISTGT_UCTL_CMD_TABLE;
1175:
1176: static ISTGT_UCTL_CMD_TABLE istgt_uctl_cmd_table[] =
1177: {
1178: { "AUTH", istgt_uctl_cmd_auth },
1179: { "QUIT", istgt_uctl_cmd_quit },
1180: { "NOOP", istgt_uctl_cmd_noop },
1181: { "VERSION", istgt_uctl_cmd_version },
1182: { "LIST", istgt_uctl_cmd_list },
1183: { "UNLOAD", istgt_uctl_cmd_unload },
1184: { "LOAD", istgt_uctl_cmd_load },
1185: { "CHANGE", istgt_uctl_cmd_change },
1186: { "RESET", istgt_uctl_cmd_reset },
1187: { "INFO", istgt_uctl_cmd_info },
1188: { NULL, NULL },
1189: };
1190:
1191: static int
1192: istgt_uctl_cmd_execute(UCTL_Ptr uctl)
1193: {
1194: int (*func) (UCTL_Ptr);
1195: const char *delim = ARGS_DELIM;
1196: char *arg;
1197: char *cmd;
1198: int rc;
1199: int i;
1200:
1201: arg = trim_string(uctl->recvbuf);
1202: cmd = strsepq(&arg, delim);
1203: uctl->arg = arg;
1204: uctl->cmd = strupr(cmd);
1205:
1206: func = NULL;
1207: for (i = 0; istgt_uctl_cmd_table[i].name != NULL; i++) {
1208: if (cmd[0] == istgt_uctl_cmd_table[i].name[0]
1209: && strcmp(cmd, istgt_uctl_cmd_table[i].name) == 0) {
1210: func = istgt_uctl_cmd_table[i].func;
1211: break;
1212: }
1213: }
1214: if (func == NULL) {
1215: istgt_uctl_snprintf(uctl, "ERR unknown command\n");
1216: rc = istgt_uctl_writeline(uctl);
1217: if (rc != UCTL_CMD_OK) {
1218: return UCTL_CMD_DISCON;
1219: }
1220: return UCTL_CMD_ERR;
1221: }
1222:
1223: if (uctl->no_auth
1224: && (strcasecmp(cmd, "AUTH") == 0)) {
1225: istgt_uctl_snprintf(uctl, "ERR auth not required\n");
1226: rc = istgt_uctl_writeline(uctl);
1227: if (rc != UCTL_CMD_OK) {
1228: return UCTL_CMD_DISCON;
1229: }
1230: return UCTL_CMD_ERR;
1231: }
1232: if (uctl->req_auth && uctl->authenticated == 0
1233: && !(strcasecmp(cmd, "QUIT") == 0
1234: || strcasecmp(cmd, "AUTH") == 0)) {
1235: istgt_uctl_snprintf(uctl, "ERR auth required\n");
1236: rc = istgt_uctl_writeline(uctl);
1237: if (rc != UCTL_CMD_OK) {
1238: return UCTL_CMD_DISCON;
1239: }
1240: return UCTL_CMD_ERR;
1241: }
1242:
1243: rc = func(uctl);
1244: return rc;
1245: }
1246:
1247: static void istgt_free_uctl(UCTL_Ptr uctl);
1248:
1249: static void *
1250: uctlworker(void *arg)
1251: {
1252: UCTL_Ptr uctl = (UCTL_Ptr) arg;
1253: int rc;
1254:
1255: ISTGT_TRACELOG(ISTGT_TRACE_NET, "connect to %s:%s,%d\n",
1256: uctl->portal.host, uctl->portal.port, uctl->portal.tag);
1257:
1258: istgt_uctl_snprintf(uctl, "iSCSI Target Controller version %s (%s)"
1259: " on %s from %s\n",
1260: ISTGT_VERSION, ISTGT_EXTRA_VERSION,
1261: uctl->saddr, uctl->caddr);
1262: rc = istgt_uctl_writeline(uctl);
1263: if (rc != UCTL_CMD_OK) {
1264: ISTGT_ERRLOG("uctl_writeline() failed\n");
1265: return NULL;
1266: }
1267:
1268: while (1) {
1269: if (istgt_get_state(uctl->istgt) != ISTGT_STATE_RUNNING) {
1270: break;
1271: }
1272:
1273: /* read from socket */
1274: rc = istgt_uctl_readline(uctl);
1275: if (rc == UCTL_CMD_EOF) {
1276: ISTGT_TRACELOG(ISTGT_TRACE_DEBUG, "uctl_readline() EOF\n");
1277: break;
1278: }
1279: if (rc != UCTL_CMD_OK) {
1280: ISTGT_ERRLOG("uctl_readline() failed\n");
1281: break;
1282: }
1283: /* execute command */
1284: rc = istgt_uctl_cmd_execute(uctl);
1285: if (rc == UCTL_CMD_QUIT) {
1286: ISTGT_TRACELOG(ISTGT_TRACE_DEBUG, "receive QUIT\n");
1287: break;
1288: }
1289: if (rc == UCTL_CMD_DISCON) {
1290: ISTGT_TRACELOG(ISTGT_TRACE_DEBUG, "request disconnect\n");
1291: break;
1292: }
1293: }
1294:
1295: ISTGT_TRACELOG(ISTGT_TRACE_DEBUG, "exiting ctlworker\n");
1296:
1297: close(uctl->sock);
1298: uctl->sock = -1;
1299: istgt_free_uctl(uctl);
1300: return NULL;
1301: }
1302:
1303: static void
1304: istgt_free_uctl(UCTL_Ptr uctl)
1305: {
1306: if (uctl == NULL)
1307: return;
1308: xfree(uctl->mediadirectory);
1309: xfree(uctl->portal.label);
1310: xfree(uctl->portal.host);
1311: xfree(uctl->portal.port);
1312: xfree(uctl->auth.user);
1313: xfree(uctl->auth.secret);
1314: xfree(uctl->auth.muser);
1315: xfree(uctl->auth.msecret);
1316: xfree(uctl);
1317: }
1318:
1319: int
1320: istgt_create_uctl(ISTGT_Ptr istgt, PORTAL_Ptr portal, int sock, struct sockaddr *sa, socklen_t salen)
1321: {
1322: char buf[MAX_TMPBUF];
1323: UCTL_Ptr uctl;
1324: int rc;
1325: int i;
1326:
1327: uctl = xmalloc(sizeof *uctl);
1328: memset(uctl, 0, sizeof *uctl);
1329:
1330: uctl->istgt = istgt;
1331: MTX_LOCK(&istgt->mutex);
1332: uctl->auth_group = istgt->uctl_auth_group;
1333: uctl->no_auth = istgt->no_uctl_auth;
1334: uctl->req_auth = istgt->req_uctl_auth;
1335: uctl->req_mutual = istgt->req_uctl_auth_mutual;
1336: uctl->mediadirectory = xstrdup(istgt->mediadirectory);
1337: MTX_UNLOCK(&istgt->mutex);
1338:
1339: uctl->portal.label = xstrdup(portal->label);
1340: uctl->portal.host = xstrdup(portal->host);
1341: uctl->portal.port = xstrdup(portal->port);
1342: uctl->portal.tag = portal->tag;
1343: uctl->portal.sock = -1;
1344: uctl->sock = sock;
1345:
1346: uctl->timeout = TIMEOUT_RW;
1347: uctl->auth.chap_phase = ISTGT_CHAP_PHASE_WAIT_A;
1348: uctl->auth.user = NULL;
1349: uctl->auth.secret = NULL;
1350: uctl->auth.muser = NULL;
1351: uctl->auth.msecret = NULL;
1352: uctl->authenticated = 0;
1353:
1354: uctl->recvtmpcnt = 0;
1355: uctl->recvtmpidx = 0;
1356: uctl->recvtmpsize = sizeof uctl->recvtmp;
1357: uctl->recvbufsize = sizeof uctl->recvbuf;
1358: uctl->sendbufsize = sizeof uctl->sendbuf;
1359: uctl->worksize = sizeof uctl->work;
1360:
1361: memset(uctl->caddr, 0, sizeof uctl->caddr);
1362: memset(uctl->saddr, 0, sizeof uctl->saddr);
1363:
1364: switch (sa->sa_family) {
1365: case AF_INET6:
1366: uctl->family = AF_INET6;
1367: rc = istgt_getaddr(sock, uctl->saddr, sizeof uctl->saddr,
1368: uctl->caddr, sizeof uctl->caddr);
1369: if (rc < 0) {
1370: ISTGT_ERRLOG("istgt_getaddr() failed\n");
1371: goto error_return;
1372: }
1373: break;
1374: case AF_INET:
1375: uctl->family = AF_INET;
1376: rc = istgt_getaddr(sock, uctl->saddr, sizeof uctl->saddr,
1377: uctl->caddr, sizeof uctl->caddr);
1378: if (rc < 0) {
1379: ISTGT_ERRLOG("istgt_getaddr() failed\n");
1380: goto error_return;
1381: }
1382: break;
1383: default:
1384: ISTGT_ERRLOG("unsupported family\n");
1385: goto error_return;
1386: }
1387:
1388: if (istgt->nuctl_netmasks != 0) {
1389: rc = -1;
1390: for (i = 0; i < istgt->nuctl_netmasks; i++) {
1391: rc = istgt_lu_allow_netmask(istgt->uctl_netmasks[i], uctl->caddr);
1392: if (rc > 0) {
1393: /* OK netmask */
1394: break;
1395: }
1396: }
1397: if (rc <= 0) {
1398: ISTGT_WARNLOG("UCTL access denied from %s to (%s:%s)\n",
1399: uctl->caddr, uctl->portal.host, uctl->portal.port);
1400: goto error_return;
1401: }
1402: }
1403:
1404: printf("sock=%d, addr=%s, peer=%s\n",
1405: sock, uctl->saddr,
1406: uctl->caddr);
1407:
1408: /* wildcard? */
1409: if (strcasecmp(uctl->portal.host, "[::]") == 0
1410: || strcasecmp(uctl->portal.host, "[*]") == 0) {
1411: if (uctl->family != AF_INET6) {
1412: ISTGT_ERRLOG("address family error\n");
1413: goto error_return;
1414: }
1415: snprintf(buf, sizeof buf, "[%s]", uctl->caddr);
1416: xfree(uctl->portal.host);
1417: uctl->portal.host = xstrdup(buf);
1418: } else if (strcasecmp(uctl->portal.host, "0.0.0.0") == 0
1419: || strcasecmp(uctl->portal.host, "*") == 0) {
1420: if (uctl->family != AF_INET) {
1421: ISTGT_ERRLOG("address family error\n");
1422: goto error_return;
1423: }
1424: snprintf(buf, sizeof buf, "%s", uctl->caddr);
1425: xfree(uctl->portal.host);
1426: uctl->portal.host = xstrdup(buf);
1427: }
1428:
1429: /* set timeout msec. */
1430: rc = istgt_set_recvtimeout(uctl->sock, uctl->timeout * 1000);
1431: if (rc != 0) {
1432: ISTGT_ERRLOG("istgt_set_recvtimeo() failed\n");
1433: goto error_return;
1434: }
1435: rc = istgt_set_sendtimeout(uctl->sock, uctl->timeout * 1000);
1436: if (rc != 0) {
1437: ISTGT_ERRLOG("istgt_set_sendtimeo() failed\n");
1438: goto error_return;
1439: }
1440:
1441: /* create new thread */
1442: #ifdef ISTGT_STACKSIZE
1443: rc = pthread_create(&uctl->thread, &istgt->attr, &uctlworker, (void *)uctl);
1444: #else
1445: rc = pthread_create(&uctl->thread, NULL, &uctlworker, (void *)uctl);
1446: #endif
1447: if (rc != 0) {
1448: ISTGT_ERRLOG("pthread_create() failed\n");
1449: error_return:
1450: xfree(uctl->portal.label);
1451: xfree(uctl->portal.host);
1452: xfree(uctl->portal.port);
1453: xfree(uctl);
1454: return -1;
1455: }
1456: rc = pthread_detach(uctl->thread);
1457: if (rc != 0) {
1458: ISTGT_ERRLOG("pthread_detach() failed\n");
1459: goto error_return;
1460: }
1461: #ifdef HAVE_PTHREAD_SET_NAME_NP
1462: pthread_set_name_np(uctl->thread, "uctlthread");
1463: #endif
1464:
1465: return 0;
1466: }
1467:
1468: int
1469: istgt_init_uctl(ISTGT_Ptr istgt)
1470: {
1471: CF_SECTION *sp;
1472: const char *val;
1473: const char *ag_tag;
1474: int alloc_len;
1475: int ag_tag_i;
1476: int masks;
1477: int i;
1478:
1479: ISTGT_TRACELOG(ISTGT_TRACE_DEBUG, "istgt_init_uctl_section\n");
1480:
1481: sp = istgt_find_cf_section(istgt->config, "UnitControl");
1482: if (sp == NULL) {
1483: ISTGT_ERRLOG("find_cf_section failed()\n");
1484: return -1;
1485: }
1486:
1487: val = istgt_get_val(sp, "Comment");
1488: if (val != NULL) {
1489: ISTGT_TRACELOG(ISTGT_TRACE_DEBUG, "Comment %s\n", val);
1490: }
1491:
1492: for (i = 0; ; i++) {
1493: val = istgt_get_nval(sp, "Netmask", i);
1494: if (val == NULL)
1495: break;
1496: }
1497: masks = i;
1498: if (masks > MAX_NETMASK) {
1499: ISTGT_ERRLOG("%d > MAX_NETMASK\n", masks);
1500: return -1;
1501: }
1502: istgt->nuctl_netmasks = masks;
1503: alloc_len = sizeof (char *) * masks;
1504: istgt->uctl_netmasks = xmalloc(alloc_len);
1505: for (i = 0; i < masks; i++) {
1506: val = istgt_get_nval(sp, "Netmask", i);
1507: ISTGT_TRACELOG(ISTGT_TRACE_DEBUG, "Netmask %s\n", val);
1508: istgt->uctl_netmasks[i] = xstrdup(val);
1509: }
1510:
1511: val = istgt_get_val(sp, "AuthMethod");
1512: if (val == NULL) {
1513: istgt->no_uctl_auth = 0;
1514: istgt->req_uctl_auth = 0;
1515: } else {
1516: istgt->no_uctl_auth = 0;
1517: for (i = 0; ; i++) {
1518: val = istgt_get_nmval(sp, "AuthMethod", 0, i);
1519: if (val == NULL)
1520: break;
1521: if (strcasecmp(val, "CHAP") == 0) {
1522: istgt->req_uctl_auth = 1;
1523: } else if (strcasecmp(val, "Mutual") == 0) {
1524: istgt->req_uctl_auth_mutual = 1;
1525: } else if (strcasecmp(val, "Auto") == 0) {
1526: istgt->req_uctl_auth = 0;
1527: istgt->req_uctl_auth_mutual = 0;
1528: } else if (strcasecmp(val, "None") == 0) {
1529: istgt->no_uctl_auth = 1;
1530: istgt->req_uctl_auth = 0;
1531: istgt->req_uctl_auth_mutual = 0;
1532: } else {
1533: ISTGT_ERRLOG("unknown auth\n");
1534: return -1;
1535: }
1536: }
1537: }
1538: if (istgt->no_uctl_auth == 0) {
1539: ISTGT_TRACELOG(ISTGT_TRACE_DEBUG, "AuthMethod None\n");
1540: } else if (istgt->req_uctl_auth == 0) {
1541: ISTGT_TRACELOG(ISTGT_TRACE_DEBUG, "AuthMethod Auto\n");
1542: } else {
1543: ISTGT_TRACELOG(ISTGT_TRACE_DEBUG, "AuthMethod %s %s\n",
1544: istgt->req_uctl_auth ? "CHAP" : "",
1545: istgt->req_uctl_auth_mutual ? "Mutual" : "");
1546: }
1547:
1548: val = istgt_get_val(sp, "AuthGroup");
1549: if (val == NULL) {
1550: istgt->uctl_auth_group = 0;
1551: } else {
1552: ag_tag = val;
1553: if (strcasecmp(ag_tag, "None") == 0) {
1554: ag_tag_i = 0;
1555: } else {
1556: if (strncasecmp(ag_tag, "AuthGroup",
1557: strlen("AuthGroup")) != 0
1558: || sscanf(ag_tag, "%*[^0-9]%d", &ag_tag_i) != 1) {
1559: ISTGT_ERRLOG("auth group error\n");
1560: return -1;
1561: }
1562: if (ag_tag_i == 0) {
1563: ISTGT_ERRLOG("invalid auth group %d\n", ag_tag_i);
1564: return -1;
1565: }
1566: }
1567: istgt->uctl_auth_group = ag_tag_i;
1568: }
1569: if (istgt->uctl_auth_group == 0) {
1570: ISTGT_TRACELOG(ISTGT_TRACE_DEBUG, "AuthGroup None\n");
1571: } else {
1572: ISTGT_TRACELOG(ISTGT_TRACE_DEBUG, "AuthGroup AuthGroup%d\n",
1573: istgt->uctl_auth_group);
1574: }
1575:
1576: return 0;
1577: }