← Back to branch summary

~ubuntu-branches/ubuntu/trusty/iscsitarget/trusty

« back to all changes in this revision

Viewing changes to usr/isns.c

  • Committer: Colin Watson
  • Date: 2010-08-16 20:59:52 UTC
  • mfrom: (2.1.9 sid)
  • Revision ID: cjwatson@canonical.com-20100816205952-hyytf817ju6wk1bj
merge from Debian 1.4.20.2-1

Show diffs side-by-side

added added

removed removed

Lines of Context:
usr/isns.c
60
60
static uint16_t transaction;
61
61
static uint32_t current_timeout = 30; /* seconds */
62
62
static char eid[ISCSI_NAME_LEN];
63
 
static uint8_t ip[16]; /* IET supoprts only one portal */
 
63
static uint8_t ip[16]; /* IET supports only one portal */
64
64
static struct sockaddr_storage ss;
65
65
 
66
66
int isns_scn_allow(uint32_t tid, char *name)
85
85
{
86
86
        int err, i;
87
87
        uint32_t addr;
88
 
        struct sockaddr_storage lss;
89
 
        socklen_t slen = sizeof(lss);
 
88
        union {
 
89
                struct sockaddr s;
 
90
                struct sockaddr_storage ss;
 
91
                struct sockaddr_in s4;
 
92
                struct sockaddr_in6 s6;
 
93
        } l;
 
94
        socklen_t slen = sizeof(l.s);
90
95
 
91
 
        err = getsockname(fd, (struct sockaddr *) &lss, &slen);
 
96
        err = getsockname(fd, &l.s, &slen);
92
97
        if (err) {
93
98
                log_error("getsockname error %s!", gai_strerror(err));
94
99
                return err;
95
100
        }
96
101
 
97
 
        err = getnameinfo((struct sockaddr *) &lss, sizeof(lss),
 
102
        err = getnameinfo(&l.s, sizeof(l.s),
98
103
                          eid, sizeof(eid), NULL, 0, 0);
99
104
        if (err) {
100
105
                log_error("getaddrinfo error %s!", gai_strerror(err));
101
106
                return err;
102
107
        }
103
108
 
104
 
        switch (lss.ss_family) {
 
109
        switch (l.ss.ss_family) {
105
110
        case AF_INET:
106
 
                addr = (((struct sockaddr_in *) &lss)->sin_addr.s_addr);
 
111
                addr = ((&l.s4)->sin_addr.s_addr);
107
112
 
108
113
                ip[10] = ip[11] = 0xff;
109
114
                ip[15] = 0xff & (addr >> 24);
113
118
                break;
114
119
        case AF_INET6:
115
120
                for (i = 0; i < ARRAY_SIZE(ip); i++)
116
 
                        ip[i] = ((struct sockaddr_in6 *) &lss)->sin6_addr.s6_addr[i];
 
121
                        ip[i] = (&l.s6)->sin6_addr.s6_addr[i];
117
122
                break;
118
123
        }
119
124
 
442
447
        while (!list_empty(&target->isns_head)) {
443
448
                ini = list_entry(target->isns_head.q_forw, typeof(*ini), ilist);
444
449
                remque(&ini->ilist);
 
450
                free(ini);
445
451
        }
446
452
}
447
453
 
595
601
        while (length) {
596
602
                uint32_t vlen = ntohl(tlv->length);
597
603
 
 
604
                if (vlen + sizeof(*tlv) > length)
 
605
                        vlen = length - sizeof(*tlv);
 
606
 
598
607
                switch (ntohl(tlv->tag)) {
599
608
                case ISNS_ATTR_ISCSI_NAME:
600
 
                        log_error("scn name: %u, %s", vlen, (char *) tlv->value);
601
 
                        if (!name)
602
 
                                name = (char *) tlv->value;
 
609
                        if (vlen) {
 
610
                                size_t slen = vlen - 1;
 
611
 
 
612
                                if (slen > ISCSI_NAME_LEN)
 
613
                                        slen = ISCSI_NAME_LEN;
 
614
 
 
615
                                *((char *) tlv->value + slen) = 0;
 
616
 
 
617
                                log_error("scn name: %u, %s", vlen,
 
618
                                          (char *) tlv->value);
 
619
 
 
620
                                if (!name)
 
621
                                        name = (char *) tlv->value;
 
622
                        }
603
623
                        break;
604
624
                case ISNS_ATTR_TIMESTAMP:
605
 
/*                      log_error("%u : %u : %" PRIx64, ntohl(tlv->tag), vlen, */
606
 
/*                                *((uint64_t *) tlv->value)); */
 
625
/*                      if (vlen == 8)
 
626
                                log_error("%u : %u : %" PRIx64, ntohl(tlv->tag),
 
627
                                          vlen, *((uint64_t *) tlv->value));
 
628
*/
607
629
                        break;
608
630
                case ISNS_ATTR_ISCSI_SCN_BITMAP:
609
 
                        log_error("scn bitmap : %x", *((uint32_t *) tlv->value));
 
631
                        if (vlen == 4)
 
632
                                log_error("scn bitmap : %x",
 
633
                                          *((uint32_t *) tlv->value));
610
634
                        break;
611
635
                }
612
636
 
666
690
 
667
691
        /* skip status */
668
692
        tlv = (struct isns_tlv *) ((char *) hdr->pdu + 4);
 
693
 
 
694
        if (length < 4)
 
695
                goto free_qry_mgmt;
 
696
 
669
697
        length -= 4;
670
698
 
671
699
        while (length) {
672
700
                uint32_t vlen = ntohl(tlv->length);
673
701
 
 
702
                if (vlen + sizeof(*tlv) > length)
 
703
                        vlen = length - sizeof(*tlv);
 
704
 
674
705
                switch (ntohl(tlv->tag)) {
675
706
                case ISNS_ATTR_ISCSI_NAME:
676
 
                        name = (char *) tlv->value;
 
707
                        if (vlen) {
 
708
                                size_t slen = vlen - 1;
 
709
 
 
710
                                if (slen > ISCSI_NAME_LEN)
 
711
                                        slen = ISCSI_NAME_LEN;
 
712
 
 
713
                                *((char *) tlv->value + slen) = 0;
 
714
 
 
715
                                name = (char *) tlv->value;
 
716
                        } else
 
717
                                name = NULL;
677
718
                        break;
678
719
                case ISNS_ATTR_ISCSI_NODE_TYPE:
679
 
                        if (ntohl(*(tlv->value)) == ISNS_NODE_INITIATOR && name) {
 
720
                        if (vlen == 4 && name &&
 
721
                            ntohl(*(tlv->value)) == ISNS_NODE_INITIATOR) {
680
722
                                log_error("%s %d: %s", __FUNCTION__, __LINE__,
681
723
                                          (char *) name);
 
724
 
682
725
                                ini = malloc(sizeof(*ini));
683
726
                                if (!ini)
684
727
                                        goto free_qry_mgmt;
 
728
 
685
729
                                snprintf(ini->name, sizeof(ini->name), "%s",
686
730
                                         name);
 
731
 
687
732
                                insque(&ini->ilist, &target->isns_head);
688
733
                        } else
689
734
                                name = NULL;
848
893
static int scn_init(char *addr)
849
894
{
850
895
        int fd, opt, err;
851
 
        struct sockaddr_storage lss;
 
896
        union {
 
897
                struct sockaddr s;
 
898
                struct sockaddr_storage ss;
 
899
                struct sockaddr_in s4;
 
900
                struct sockaddr_in6 s6;
 
901
        } l;
852
902
        socklen_t slen;
853
903
 
854
904
        fd = socket(ss.ss_family, SOCK_STREAM, IPPROTO_TCP);
872
922
                goto out;
873
923
        }
874
924
 
875
 
        slen = sizeof(lss);
876
 
        err = getsockname(fd, (struct sockaddr *) &lss, &slen);
 
925
        slen = sizeof(l.s);
 
926
        err = getsockname(fd, &l.s, &slen);
877
927
        if (err) {
878
928
                log_error("%s %d: %s\n", __FUNCTION__, __LINE__, strerror(errno));
879
929
                goto out;
880
930
        }
881
931
 
882
932
        /* protocol independent way ? */
883
 
        if (lss.ss_family == AF_INET6)
884
 
                scn_listen_port = ntohs(((struct sockaddr_in6 *) &lss)->sin6_port);
 
933
        if (l.ss.ss_family == AF_INET6)
 
934
                scn_listen_port = ntohs((&l.s6)->sin6_port);
885
935
        else
886
 
                scn_listen_port = ntohs(((struct sockaddr_in *) &lss)->sin_port);
 
936
                scn_listen_port = ntohs((&l.s4)->sin_port);
887
937
 
888
938
        log_error("scn listen port %u %d %d\n", scn_listen_port, fd, err);
889
939
out:
911
961
                log_error("getaddrinfo error %s, %s", gai_strerror(err), addr);
912
962
                return -1;
913
963
        }
914
 
        memcpy(&ss, res->ai_addr, sizeof(ss));
 
964
        memcpy(&ss, res->ai_addr, sizeof(*res->ai_addr));
915
965
        freeaddrinfo(res);
916
966
 
917
967
        rxbuf = calloc(2, BUFSIZE);