emlxs_dhchap.c (a9800beb) emlxs_dhchap.c (8f23e9fa)
1/*
2 * CDDL HEADER START
3 *
4 * The contents of this file are subject to the terms of the
5 * Common Development and Distribution License (the "License").
6 * You may not use this file except in compliance with the License.
7 *
1/*
2 * CDDL HEADER START
3 *
4 * The contents of this file are subject to the terms of the
5 * Common Development and Distribution License (the "License").
6 * You may not use this file except in compliance with the License.
7 *
8 * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE
9 * or http://www.opensolaris.org/os/licensing.
8 * You can obtain a copy of the license at
9 * http://www.opensource.org/licenses/cddl1.txt.
10 * See the License for the specific language governing permissions
11 * and limitations under the License.
12 *
13 * When distributing Covered Code, include this CDDL HEADER in each
14 * file and include the License file at usr/src/OPENSOLARIS.LICENSE.
15 * If applicable, add the following below this CDDL HEADER, with the
16 * fields enclosed by brackets "[]" replaced with your own identifying
17 * information: Portions Copyright [yyyy] [name of copyright owner]
18 *
19 * CDDL HEADER END
20 */
21
22/*
10 * See the License for the specific language governing permissions
11 * and limitations under the License.
12 *
13 * When distributing Covered Code, include this CDDL HEADER in each
14 * file and include the License file at usr/src/OPENSOLARIS.LICENSE.
15 * If applicable, add the following below this CDDL HEADER, with the
16 * fields enclosed by brackets "[]" replaced with your own identifying
17 * information: Portions Copyright [yyyy] [name of copyright owner]
18 *
19 * CDDL HEADER END
20 */
21
22/*
23 * Copyright 2010 Emulex. All rights reserved.
23 * Copyright (c) 2004-2011 Emulex. All rights reserved.
24 * Use is subject to license terms.
25 */
26
24 * Use is subject to license terms.
25 */
26
27
28#include <emlxs.h>
29
30#ifdef DHCHAP_SUPPORT
31
32#include <md5.h>
33#include <sha1.h>
27#include <emlxs.h>
28
29#ifdef DHCHAP_SUPPORT
30
31#include <md5.h>
32#include <sha1.h>
34#ifdef S10
35#include <sha1_consts.h>
36#else
37#include <sys/sha1_consts.h>
33#include <sys/sha1_consts.h>
38#endif /* S10 */
39#include <bignum.h>
40#include <sys/time.h>
41
34#include <bignum.h>
35#include <sys/time.h>
36
42#ifdef S10
43#define BIGNUM_CHUNK_32
44#define BIG_CHUNK_TYPE uint32_t
45#define CHARLEN2BIGNUMLEN(_val) (_val/4)
46#endif /* S10 */
47
48#define RAND
49
50#ifndef ENABLE
51#define ENABLE 1
52#endif /* ENABLE */
53
54#ifndef DISABLE

--- 345 unchanged lines hidden (view full) ---

400
401 count = sizeof (emlxs_event_table) / sizeof (emlxs_table_t);
402 for (i = 0; i < count; i++) {
403 if (state == emlxs_event_table[i].code) {
404 return (emlxs_event_table[i].string);
405 }
406 }
407
37
38#define RAND
39
40#ifndef ENABLE
41#define ENABLE 1
42#endif /* ENABLE */
43
44#ifndef DISABLE

--- 345 unchanged lines hidden (view full) ---

390
391 count = sizeof (emlxs_event_table) / sizeof (emlxs_table_t);
392 for (i = 0; i < count; i++) {
393 if (state == emlxs_event_table[i].code) {
394 return (emlxs_event_table[i].string);
395 }
396 }
397
408 (void) sprintf(buffer, "event=0x%x", state);
398 (void) snprintf(buffer, sizeof (buffer), "event=0x%x", state);
409 return (buffer);
410
411} /* emlxs_dhc_event_xlate() */
412
413
414extern void
415emlxs_dhc_state(emlxs_port_t *port, emlxs_node_t *ndlp, uint32_t state,
416 uint32_t reason, uint32_t explaination)

--- 338 unchanged lines hidden (view full) ---

755
756 count = sizeof (emlxs_pstate_table) / sizeof (emlxs_table_t);
757 for (i = 0; i < count; i++) {
758 if (state == emlxs_pstate_table[i].code) {
759 return (emlxs_pstate_table[i].string);
760 }
761 }
762
399 return (buffer);
400
401} /* emlxs_dhc_event_xlate() */
402
403
404extern void
405emlxs_dhc_state(emlxs_port_t *port, emlxs_node_t *ndlp, uint32_t state,
406 uint32_t reason, uint32_t explaination)

--- 338 unchanged lines hidden (view full) ---

745
746 count = sizeof (emlxs_pstate_table) / sizeof (emlxs_table_t);
747 for (i = 0; i < count; i++) {
748 if (state == emlxs_pstate_table[i].code) {
749 return (emlxs_pstate_table[i].string);
750 }
751 }
752
763 (void) sprintf(buffer, "state=0x%x", state);
753 (void) snprintf(buffer, sizeof (buffer), "state=0x%x", state);
764 return (buffer);
765
766} /* emlxs_dhc_pstate_xlate() */
767
768
769static char *
770emlxs_dhc_nstate_xlate(uint32_t state)
771{
772 static char buffer[32];
773 uint32_t i;
774 uint32_t count;
775
776 count = sizeof (emlxs_nstate_table) / sizeof (emlxs_table_t);
777 for (i = 0; i < count; i++) {
778 if (state == emlxs_nstate_table[i].code) {
779 return (emlxs_nstate_table[i].string);
780 }
781 }
782
754 return (buffer);
755
756} /* emlxs_dhc_pstate_xlate() */
757
758
759static char *
760emlxs_dhc_nstate_xlate(uint32_t state)
761{
762 static char buffer[32];
763 uint32_t i;
764 uint32_t count;
765
766 count = sizeof (emlxs_nstate_table) / sizeof (emlxs_table_t);
767 for (i = 0; i < count; i++) {
768 if (state == emlxs_nstate_table[i].code) {
769 return (emlxs_nstate_table[i].string);
770 }
771 }
772
783 (void) sprintf(buffer, "state=0x%x", state);
773 (void) snprintf(buffer, sizeof (buffer), "state=0x%x", state);
784 return (buffer);
785
786} /* emlxs_dhc_nstate_xlate() */
787
788
789static uint32_t
790emlxs_check_dhgp(
791 emlxs_port_t *port,

--- 69 unchanged lines hidden (view full) ---

861
862 if (i == wnt) {
863 /* no match */
864 rc = 1;
865 return (1);
866 }
867
868 EMLXS_MSGF(EMLXS_CONTEXT, &emlxs_fcsp_detail_msg,
774 return (buffer);
775
776} /* emlxs_dhc_nstate_xlate() */
777
778
779static uint32_t
780emlxs_check_dhgp(
781 emlxs_port_t *port,

--- 69 unchanged lines hidden (view full) ---

851
852 if (i == wnt) {
853 /* no match */
854 rc = 1;
855 return (1);
856 }
857
858 EMLXS_MSGF(EMLXS_CONTEXT, &emlxs_fcsp_detail_msg,
869 "emlxs_check_dhgp: dhgp_id=0x%x", *dhgp_id);
859 "check_dhgp: dhgp_id=0x%x", *dhgp_id);
870
871 return (rc);
872} /* emlxs_check_dhgp */
873
874
875static void
876emlxs_get_random_bytes(
877 NODELIST *ndlp,

--- 167 unchanged lines hidden (view full) ---

1045/* MATCHMAP * mp, */ void *arg3,
1046/* NODELIST * ndlp */ void *arg4,
1047uint32_t evt)
1048{
1049 NODELIST *ndlp = (NODELIST *) arg4;
1050 emlxs_node_dhc_t *node_dhc = &ndlp->node_dhc;
1051
1052 EMLXS_MSGF(EMLXS_CONTEXT, &emlxs_fcsp_detail_msg,
860
861 return (rc);
862} /* emlxs_check_dhgp */
863
864
865static void
866emlxs_get_random_bytes(
867 NODELIST *ndlp,

--- 167 unchanged lines hidden (view full) ---

1035/* MATCHMAP * mp, */ void *arg3,
1036/* NODELIST * ndlp */ void *arg4,
1037uint32_t evt)
1038{
1039 NODELIST *ndlp = (NODELIST *) arg4;
1040 emlxs_node_dhc_t *node_dhc = &ndlp->node_dhc;
1041
1042 EMLXS_MSGF(EMLXS_CONTEXT, &emlxs_fcsp_detail_msg,
1053 "emlxs_disc_neverdev: did=0x%x.",
1043 "disc_neverdev: did=0x%x.",
1054 ndlp->nlp_DID);
1055
1056 emlxs_dhc_state(port, ndlp, NODE_STATE_UNKNOWN, 0, 0);
1057
1058 return (node_dhc->state);
1059
1060} /* emlxs_disc_neverdev() */
1061

--- 15 unchanged lines hidden (view full) ---

1077 NODELIST *ndlp;
1078 uint32_t did;
1079
1080 did = pkt->pkt_cmd_fhdr.d_id;
1081 sbp = (emlxs_buf_t *)pkt->pkt_fca_private;
1082 ndlp = sbp->node;
1083
1084 if (!ndlp) {
1044 ndlp->nlp_DID);
1045
1046 emlxs_dhc_state(port, ndlp, NODE_STATE_UNKNOWN, 0, 0);
1047
1048 return (node_dhc->state);
1049
1050} /* emlxs_disc_neverdev() */
1051

--- 15 unchanged lines hidden (view full) ---

1067 NODELIST *ndlp;
1068 uint32_t did;
1069
1070 did = pkt->pkt_cmd_fhdr.d_id;
1071 sbp = (emlxs_buf_t *)pkt->pkt_fca_private;
1072 ndlp = sbp->node;
1073
1074 if (!ndlp) {
1085 ndlp = emlxs_node_find_did(port, did);
1075 ndlp = emlxs_node_find_did(port, did, 1);
1086 }
1087 if (pkt->pkt_state != FC_PKT_SUCCESS) {
1088 EMLXS_MSGF(EMLXS_CONTEXT, &emlxs_fcsp_detail_msg,
1076 }
1077 if (pkt->pkt_state != FC_PKT_SUCCESS) {
1078 EMLXS_MSGF(EMLXS_CONTEXT, &emlxs_fcsp_detail_msg,
1089 "emlxs_cmpl_dhchap_challenge_issue: did=0x%x state=%x",
1079 "cmpl_dhchap_challenge_issue: did=0x%x state=%x",
1090 did, pkt->pkt_state);
1091 } else {
1092 EMLXS_MSGF(EMLXS_CONTEXT, &emlxs_fcsp_detail_msg,
1080 did, pkt->pkt_state);
1081 } else {
1082 EMLXS_MSGF(EMLXS_CONTEXT, &emlxs_fcsp_detail_msg,
1093 "emlxs_cmpl_dhchap_challenge_issue: did=0x%x. Succcess.",
1083 "cmpl_dhchap_challenge_issue: did=0x%x. Succcess.",
1094 did);
1095 }
1096
1097 if (ndlp) {
1098 if (pkt->pkt_state == FC_PKT_SUCCESS) {
1099 (void) emlxs_dhchap_state_machine(port, NULL, NULL,
1100 NULL, ndlp, NODE_EVENT_CMPL_AUTH_MSG);
1101 }

--- 23 unchanged lines hidden (view full) ---

1125 uint32_t did;
1126 emlxs_buf_t *sbp;
1127
1128 did = pkt->pkt_cmd_fhdr.d_id;
1129 sbp = (emlxs_buf_t *)pkt->pkt_fca_private;
1130 ndlp = sbp->node;
1131
1132 if (!ndlp) {
1084 did);
1085 }
1086
1087 if (ndlp) {
1088 if (pkt->pkt_state == FC_PKT_SUCCESS) {
1089 (void) emlxs_dhchap_state_machine(port, NULL, NULL,
1090 NULL, ndlp, NODE_EVENT_CMPL_AUTH_MSG);
1091 }

--- 23 unchanged lines hidden (view full) ---

1115 uint32_t did;
1116 emlxs_buf_t *sbp;
1117
1118 did = pkt->pkt_cmd_fhdr.d_id;
1119 sbp = (emlxs_buf_t *)pkt->pkt_fca_private;
1120 ndlp = sbp->node;
1121
1122 if (!ndlp) {
1133 ndlp = emlxs_node_find_did(port, did);
1123 ndlp = emlxs_node_find_did(port, did, 1);
1134 }
1135 if (pkt->pkt_state != FC_PKT_SUCCESS) {
1136 EMLXS_MSGF(EMLXS_CONTEXT, &emlxs_fcsp_detail_msg,
1124 }
1125 if (pkt->pkt_state != FC_PKT_SUCCESS) {
1126 EMLXS_MSGF(EMLXS_CONTEXT, &emlxs_fcsp_detail_msg,
1137 "emlxs_cmpl_dhchap_success_issue: 0x%x %x. No retry.",
1127 "cmpl_dhchap_success_issue: 0x%x %x. No retry.",
1138 did, pkt->pkt_state);
1139 } else {
1140 EMLXS_MSGF(EMLXS_CONTEXT, &emlxs_fcsp_detail_msg,
1128 did, pkt->pkt_state);
1129 } else {
1130 EMLXS_MSGF(EMLXS_CONTEXT, &emlxs_fcsp_detail_msg,
1141 "emlxs_cmpl_dhchap_success_issue: did=0x%x. Succcess.",
1131 "cmpl_dhchap_success_issue: did=0x%x. Succcess.",
1142 did);
1143 }
1144
1145 if (ndlp) {
1146 if (pkt->pkt_state == FC_PKT_SUCCESS) {
1147 (void) emlxs_dhchap_state_machine(port, NULL, NULL,
1148 NULL, ndlp, NODE_EVENT_CMPL_AUTH_MSG);
1149 }

--- 25 unchanged lines hidden (view full) ---

1175 uint8_t *pCmd;
1176 uint16_t cmdsize;
1177 DHCHAP_SUCCESS_HDR *ap;
1178 uint8_t *tmp;
1179 uint32_t len;
1180 uint32_t ret;
1181
1182 EMLXS_MSGF(EMLXS_CONTEXT, &emlxs_fcsp_detail_msg,
1132 did);
1133 }
1134
1135 if (ndlp) {
1136 if (pkt->pkt_state == FC_PKT_SUCCESS) {
1137 (void) emlxs_dhchap_state_machine(port, NULL, NULL,
1138 NULL, ndlp, NODE_EVENT_CMPL_AUTH_MSG);
1139 }

--- 25 unchanged lines hidden (view full) ---

1165 uint8_t *pCmd;
1166 uint16_t cmdsize;
1167 DHCHAP_SUCCESS_HDR *ap;
1168 uint8_t *tmp;
1169 uint32_t len;
1170 uint32_t ret;
1171
1172 EMLXS_MSGF(EMLXS_CONTEXT, &emlxs_fcsp_detail_msg,
1183 "emlxs_issue_dhchap_success: did=0x%x", ndlp->nlp_DID);
1173 "issue_dhchap_success: did=0x%x", ndlp->nlp_DID);
1184
1185 if (ndlp->nlp_DID == FABRIC_DID) {
1186 if (node_dhc->nlp_auth_hashid == AUTH_MD5)
1187 len = MD5_LEN;
1188 else
1189 len = SHA1_LEN;
1190 } else {
1191 len = (node_dhc->nlp_auth_hashid == AUTH_MD5) ?

--- 34 unchanged lines hidden (view full) ---

1226 * DHCHAP_Success expected.
1227 *
1228 * In case of rsp != NULL it indicates this DHCHAP_Success is issued
1229 * when host is the responder AND this DHCHAP_Success has reply
1230 * embedded therefore the host expects DHCHAP_Success from other
1231 * entity in transaction.
1232 */
1233 EMLXS_MSGF(EMLXS_CONTEXT, &emlxs_fcsp_detail_msg,
1174
1175 if (ndlp->nlp_DID == FABRIC_DID) {
1176 if (node_dhc->nlp_auth_hashid == AUTH_MD5)
1177 len = MD5_LEN;
1178 else
1179 len = SHA1_LEN;
1180 } else {
1181 len = (node_dhc->nlp_auth_hashid == AUTH_MD5) ?

--- 34 unchanged lines hidden (view full) ---

1216 * DHCHAP_Success expected.
1217 *
1218 * In case of rsp != NULL it indicates this DHCHAP_Success is issued
1219 * when host is the responder AND this DHCHAP_Success has reply
1220 * embedded therefore the host expects DHCHAP_Success from other
1221 * entity in transaction.
1222 */
1223 EMLXS_MSGF(EMLXS_CONTEXT, &emlxs_fcsp_detail_msg,
1234 "emlxs_issue_dhchap_success: 0x%x 0x%x 0x%x 0x%x 0x%x %p",
1224 "issue_dhchap_success: 0x%x 0x%x 0x%x 0x%x 0x%x %p",
1235 ndlp->nlp_DID, node_dhc->nlp_auth_hashid,
1236 node_dhc->nlp_auth_tranid_rsp,
1237 node_dhc->nlp_auth_tranid_ini, cmdsize, rsp);
1238
1239 if (rsp == NULL) {
1240 ap->msg_len = LE_SWAP32(0x00000004);
1241 ap->RspVal_len = 0x0;
1242

--- 15 unchanged lines hidden (view full) ---

1258 if (node_dhc->nlp_auth_flag == 2) {
1259 ap->tran_id =
1260 LE_SWAP32(node_dhc->nlp_auth_tranid_rsp);
1261 } else if (node_dhc->nlp_auth_flag == 1) {
1262 ap->tran_id =
1263 LE_SWAP32(node_dhc->nlp_auth_tranid_ini);
1264 } else {
1265 EMLXS_MSGF(EMLXS_CONTEXT, &emlxs_fcsp_debug_msg,
1225 ndlp->nlp_DID, node_dhc->nlp_auth_hashid,
1226 node_dhc->nlp_auth_tranid_rsp,
1227 node_dhc->nlp_auth_tranid_ini, cmdsize, rsp);
1228
1229 if (rsp == NULL) {
1230 ap->msg_len = LE_SWAP32(0x00000004);
1231 ap->RspVal_len = 0x0;
1232

--- 15 unchanged lines hidden (view full) ---

1248 if (node_dhc->nlp_auth_flag == 2) {
1249 ap->tran_id =
1250 LE_SWAP32(node_dhc->nlp_auth_tranid_rsp);
1251 } else if (node_dhc->nlp_auth_flag == 1) {
1252 ap->tran_id =
1253 LE_SWAP32(node_dhc->nlp_auth_tranid_ini);
1254 } else {
1255 EMLXS_MSGF(EMLXS_CONTEXT, &emlxs_fcsp_debug_msg,
1266 "emlxs_is_dhch_success: (1) 0x%x 0x%x 0x%x 0x%x",
1256 "is_dhch_success: (1) 0x%x 0x%x 0x%x 0x%x",
1267 ndlp->nlp_DID, node_dhc->nlp_auth_flag,
1268 node_dhc->nlp_auth_tranid_rsp,
1269 node_dhc->nlp_auth_tranid_ini);
1270
1271 return (1);
1272 }
1273 }
1274
1275 pkt->pkt_comp = emlxs_cmpl_dhchap_success_issue;
1276
1277 ret = emlxs_pkt_send(pkt, 1);
1278
1279 if (ret != FC_SUCCESS) {
1280 EMLXS_MSGF(EMLXS_CONTEXT, &emlxs_fcsp_detail_msg,
1257 ndlp->nlp_DID, node_dhc->nlp_auth_flag,
1258 node_dhc->nlp_auth_tranid_rsp,
1259 node_dhc->nlp_auth_tranid_ini);
1260
1261 return (1);
1262 }
1263 }
1264
1265 pkt->pkt_comp = emlxs_cmpl_dhchap_success_issue;
1266
1267 ret = emlxs_pkt_send(pkt, 1);
1268
1269 if (ret != FC_SUCCESS) {
1270 EMLXS_MSGF(EMLXS_CONTEXT, &emlxs_fcsp_detail_msg,
1281 "emlxs_issue_dhchap_success: Unable to send packet. 0x%x",
1271 "issue_dhchap_success: Unable to send packet. 0x%x",
1282 ret);
1283
1284 emlxs_pkt_free(pkt);
1285
1286 return (1);
1287 }
1288 return (0);
1289

--- 16 unchanged lines hidden (view full) ---

1306 NODELIST *ndlp;
1307 uint32_t did;
1308
1309 did = pkt->pkt_cmd_fhdr.d_id;
1310 sbp = (emlxs_buf_t *)pkt->pkt_fca_private;
1311 ndlp = sbp->node;
1312
1313 if (!ndlp) {
1272 ret);
1273
1274 emlxs_pkt_free(pkt);
1275
1276 return (1);
1277 }
1278 return (0);
1279

--- 16 unchanged lines hidden (view full) ---

1296 NODELIST *ndlp;
1297 uint32_t did;
1298
1299 did = pkt->pkt_cmd_fhdr.d_id;
1300 sbp = (emlxs_buf_t *)pkt->pkt_fca_private;
1301 ndlp = sbp->node;
1302
1303 if (!ndlp) {
1314 ndlp = emlxs_node_find_did(port, did);
1304 ndlp = emlxs_node_find_did(port, did, 1);
1315 }
1316 if (pkt->pkt_state != FC_PKT_SUCCESS) {
1317 EMLXS_MSGF(EMLXS_CONTEXT, &emlxs_fcsp_detail_msg,
1305 }
1306 if (pkt->pkt_state != FC_PKT_SUCCESS) {
1307 EMLXS_MSGF(EMLXS_CONTEXT, &emlxs_fcsp_detail_msg,
1318 "emlxs_cmpl_auth_reject_issue: 0x%x %x. No retry.",
1308 "cmpl_auth_reject_issue: 0x%x %x. No retry.",
1319 did, pkt->pkt_state);
1320 } else {
1321 EMLXS_MSGF(EMLXS_CONTEXT, &emlxs_fcsp_detail_msg,
1309 did, pkt->pkt_state);
1310 } else {
1311 EMLXS_MSGF(EMLXS_CONTEXT, &emlxs_fcsp_detail_msg,
1322 "emlxs_cmpl_auth_reject_issue: did=0x%x. Succcess.",
1312 "cmpl_auth_reject_issue: did=0x%x. Succcess.",
1323 did);
1324 }
1325
1326 if (ndlp) {
1327 /* setup the new state */
1328 emlxs_dhc_state(port, ndlp, NODE_STATE_AUTH_FAILED, 0, 0);
1329
1330 if (pkt->pkt_state == FC_PKT_SUCCESS) {

--- 82 unchanged lines hidden (view full) ---

1413 "Auth reject failed. Unable to send pkt. 0x%x %x expl=%x",
1414 ndlp->nlp_DID, node_dhc->nlp_auth_flag, ReasonCode,
1415 ReasonCodeExplanation);
1416
1417 emlxs_pkt_free(pkt);
1418
1419 return (1);
1420 }
1313 did);
1314 }
1315
1316 if (ndlp) {
1317 /* setup the new state */
1318 emlxs_dhc_state(port, ndlp, NODE_STATE_AUTH_FAILED, 0, 0);
1319
1320 if (pkt->pkt_state == FC_PKT_SUCCESS) {

--- 82 unchanged lines hidden (view full) ---

1403 "Auth reject failed. Unable to send pkt. 0x%x %x expl=%x",
1404 ndlp->nlp_DID, node_dhc->nlp_auth_flag, ReasonCode,
1405 ReasonCodeExplanation);
1406
1407 emlxs_pkt_free(pkt);
1408
1409 return (1);
1410 }
1421 (void) sprintf(info,
1411 (void) snprintf(info, sizeof (info),
1422 "Auth-Reject: ReasonCode=0x%x, ReasonCodeExplanation=0x%x",
1423 ReasonCode, ReasonCodeExplanation);
1424
1412 "Auth-Reject: ReasonCode=0x%x, ReasonCodeExplanation=0x%x",
1413 ReasonCode, ReasonCodeExplanation);
1414
1425 emlxs_log_auth_event(port, ndlp, ESC_EMLXS_28, info);
1415 emlxs_log_auth_event(port, ndlp, "issue_auth_reject", info);
1426
1427 return (0);
1428
1429} /* emlxs_issue_auth_reject */
1430
1431
1432static fc_packet_t *
1433 emlxs_prep_els_fc_pkt(

--- 46 unchanged lines hidden (view full) ---

1480 * entity ndlp. When this Auth_Negotiate command is completed, the iocb_cmpl
1481 * will get called as the solicited mbox cmd
1482 * callback. Some switch only support NULL dhchap in which case negotiate
1483 * should be modified to only have NULL DH specificed.
1484 *
1485 */
1486/* ARGSUSED */
1487static int
1416
1417 return (0);
1418
1419} /* emlxs_issue_auth_reject */
1420
1421
1422static fc_packet_t *
1423 emlxs_prep_els_fc_pkt(

--- 46 unchanged lines hidden (view full) ---

1470 * entity ndlp. When this Auth_Negotiate command is completed, the iocb_cmpl
1471 * will get called as the solicited mbox cmd
1472 * callback. Some switch only support NULL dhchap in which case negotiate
1473 * should be modified to only have NULL DH specificed.
1474 *
1475 */
1476/* ARGSUSED */
1477static int
1488 emlxs_issue_auth_negotiate(
1478emlxs_issue_auth_negotiate(
1489 emlxs_port_t *port,
1490 emlxs_node_t *ndlp,
1491 uint8_t retry)
1492{
1493 emlxs_node_dhc_t *node_dhc = &ndlp->node_dhc;
1494 fc_packet_t *pkt;
1495 uint32_t cmd_size;
1496 uint32_t rsp_size;

--- 391 unchanged lines hidden (view full) ---

1888 uint32_t did;
1889
1890 did = pkt->pkt_cmd_fhdr.d_id;
1891 sbp = (emlxs_buf_t *)pkt->pkt_fca_private;
1892 ndlp = sbp->node;
1893 node_dhc = &ndlp->node_dhc;
1894
1895 if (!ndlp) {
1479 emlxs_port_t *port,
1480 emlxs_node_t *ndlp,
1481 uint8_t retry)
1482{
1483 emlxs_node_dhc_t *node_dhc = &ndlp->node_dhc;
1484 fc_packet_t *pkt;
1485 uint32_t cmd_size;
1486 uint32_t rsp_size;

--- 391 unchanged lines hidden (view full) ---

1878 uint32_t did;
1879
1880 did = pkt->pkt_cmd_fhdr.d_id;
1881 sbp = (emlxs_buf_t *)pkt->pkt_fca_private;
1882 ndlp = sbp->node;
1883 node_dhc = &ndlp->node_dhc;
1884
1885 if (!ndlp) {
1896 ndlp = emlxs_node_find_did(port, did);
1886 ndlp = emlxs_node_find_did(port, did, 1);
1897 }
1898 if (pkt->pkt_state != FC_PKT_SUCCESS) {
1899 EMLXS_MSGF(EMLXS_CONTEXT, &emlxs_fcsp_detail_msg,
1887 }
1888 if (pkt->pkt_state != FC_PKT_SUCCESS) {
1889 EMLXS_MSGF(EMLXS_CONTEXT, &emlxs_fcsp_detail_msg,
1900 "emlxs_cmpl_dhchap_negotiate_issue: 0x%x %x. Noretry.",
1890 "cmpl_dhchap_negotiate_issue: 0x%x %x. Noretry.",
1901 did, pkt->pkt_state);
1902 } else {
1903 EMLXS_MSGF(EMLXS_CONTEXT, &emlxs_fcsp_detail_msg,
1891 did, pkt->pkt_state);
1892 } else {
1893 EMLXS_MSGF(EMLXS_CONTEXT, &emlxs_fcsp_detail_msg,
1904 "emlxs_cmpl_dhchap_negotiate_issue: did=0x%x. Succcess.",
1894 "cmpl_dhchap_negotiate_issue: did=0x%x. Succcess.",
1905 did);
1906 }
1907
1908 if (ndlp) {
1909 if (pkt->pkt_state == FC_PKT_SUCCESS) {
1910 (void) emlxs_dhchap_state_machine(port, NULL, NULL,
1911 NULL, ndlp, NODE_EVENT_CMPL_AUTH_MSG);
1912 } else {

--- 39 unchanged lines hidden (view full) ---

1952/* MATCHMAP * mp, */ void *arg3,
1953/* NODELIST * ndlp, */ void *arg4,
1954uint32_t evt)
1955{
1956 NODELIST *ndlp = (NODELIST *)arg4;
1957 emlxs_node_dhc_t *node_dhc = &ndlp->node_dhc;
1958
1959 EMLXS_MSGF(EMLXS_CONTEXT, &emlxs_fcsp_detail_msg,
1895 did);
1896 }
1897
1898 if (ndlp) {
1899 if (pkt->pkt_state == FC_PKT_SUCCESS) {
1900 (void) emlxs_dhchap_state_machine(port, NULL, NULL,
1901 NULL, ndlp, NODE_EVENT_CMPL_AUTH_MSG);
1902 } else {

--- 39 unchanged lines hidden (view full) ---

1942/* MATCHMAP * mp, */ void *arg3,
1943/* NODELIST * ndlp, */ void *arg4,
1944uint32_t evt)
1945{
1946 NODELIST *ndlp = (NODELIST *)arg4;
1947 emlxs_node_dhc_t *node_dhc = &ndlp->node_dhc;
1948
1949 EMLXS_MSGF(EMLXS_CONTEXT, &emlxs_fcsp_detail_msg,
1960 "emlxs_cmpl_auth_msg_auth_negotiate_issue: did=0x%x",
1950 "cmpl_auth_msg_auth_negotiate_issue: did=0x%x",
1961 ndlp->nlp_DID);
1962
1963 /* start the emlxs_dhc_authrsp_timeout timer */
1964 if (node_dhc->nlp_authrsp_tmo == 0) {
1965 node_dhc->nlp_authrsp_tmo = DRV_TIME +
1966 node_dhc->auth_cfg.authentication_timeout;
1967 }
1968 /*

--- 49 unchanged lines hidden (view full) ---

2018{
2019 NODELIST *ndlp = (NODELIST *)arg4;
2020 emlxs_node_dhc_t *node_dhc = &ndlp->node_dhc;
2021 IOCBQ *iocbq = (IOCBQ *) arg2;
2022 uint8_t ReasonCode;
2023 uint8_t ReasonCodeExplanation;
2024
2025 EMLXS_MSGF(EMLXS_CONTEXT, &emlxs_fcsp_detail_msg,
1951 ndlp->nlp_DID);
1952
1953 /* start the emlxs_dhc_authrsp_timeout timer */
1954 if (node_dhc->nlp_authrsp_tmo == 0) {
1955 node_dhc->nlp_authrsp_tmo = DRV_TIME +
1956 node_dhc->auth_cfg.authentication_timeout;
1957 }
1958 /*

--- 49 unchanged lines hidden (view full) ---

2008{
2009 NODELIST *ndlp = (NODELIST *)arg4;
2010 emlxs_node_dhc_t *node_dhc = &ndlp->node_dhc;
2011 IOCBQ *iocbq = (IOCBQ *) arg2;
2012 uint8_t ReasonCode;
2013 uint8_t ReasonCodeExplanation;
2014
2015 EMLXS_MSGF(EMLXS_CONTEXT, &emlxs_fcsp_detail_msg,
2026 "emlxs_rcv_auth_msg_auth_negotiate_issue: did=0x%x",
2016 "rcv_auth_msg_auth_negotiate_issue: did=0x%x",
2027 ndlp->nlp_DID);
2028
2029 /* Anyway we accept it first and then send auth_reject */
2030 (void) emlxs_els_reply(port, iocbq, ELS_CMD_ACC, ELS_CMD_AUTH, 0, 0);
2031
2032 /* host is always the initiator and it should win */
2033 ReasonCode = AUTHRJT_LOGIC_ERR;
2034 ReasonCodeExplanation = AUTHEXP_AUTHTRAN_STARTED;

--- 24 unchanged lines hidden (view full) ---

2059 NODELIST *ndlp;
2060 uint32_t did;
2061
2062 did = pkt->pkt_cmd_fhdr.d_id;
2063 sbp = (emlxs_buf_t *)pkt->pkt_fca_private;
2064 ndlp = sbp->node;
2065
2066 if (!ndlp) {
2017 ndlp->nlp_DID);
2018
2019 /* Anyway we accept it first and then send auth_reject */
2020 (void) emlxs_els_reply(port, iocbq, ELS_CMD_ACC, ELS_CMD_AUTH, 0, 0);
2021
2022 /* host is always the initiator and it should win */
2023 ReasonCode = AUTHRJT_LOGIC_ERR;
2024 ReasonCodeExplanation = AUTHEXP_AUTHTRAN_STARTED;

--- 24 unchanged lines hidden (view full) ---

2049 NODELIST *ndlp;
2050 uint32_t did;
2051
2052 did = pkt->pkt_cmd_fhdr.d_id;
2053 sbp = (emlxs_buf_t *)pkt->pkt_fca_private;
2054 ndlp = sbp->node;
2055
2056 if (!ndlp) {
2067 ndlp = emlxs_node_find_did(port, did);
2057 ndlp = emlxs_node_find_did(port, did, 1);
2068 }
2069 if (pkt->pkt_state != FC_PKT_SUCCESS) {
2070 EMLXS_MSGF(EMLXS_CONTEXT, &emlxs_fcsp_detail_msg,
2058 }
2059 if (pkt->pkt_state != FC_PKT_SUCCESS) {
2060 EMLXS_MSGF(EMLXS_CONTEXT, &emlxs_fcsp_detail_msg,
2071 "emlxs_cmpl_dhchap_reply_issue: 0x%x %x. No retry.",
2061 "cmpl_dhchap_reply_issue: 0x%x %x. No retry.",
2072 did, pkt->pkt_state);
2073 } else {
2074 EMLXS_MSGF(EMLXS_CONTEXT, &emlxs_fcsp_detail_msg,
2062 did, pkt->pkt_state);
2063 } else {
2064 EMLXS_MSGF(EMLXS_CONTEXT, &emlxs_fcsp_detail_msg,
2075 "emlxs_cmpl_dhchap_reply_issue: did=0x%x. Succcess.",
2065 "cmpl_dhchap_reply_issue: did=0x%x. Succcess.",
2076 did);
2077 }
2078
2079 if (ndlp) {
2080 if (pkt->pkt_state == FC_PKT_SUCCESS) {
2081 (void) emlxs_dhchap_state_machine(port, NULL, NULL,
2082 NULL, ndlp, NODE_EVENT_CMPL_AUTH_MSG);
2083 }

--- 45 unchanged lines hidden (view full) ---

2129 uint32_t tran_id;
2130 BIG_ERR_CODE err = BIG_OK;
2131
2132 /*
2133 * we assume the HBAnyware should configure the driver the right
2134 * parameters for challenge. for now, we create our own challenge.
2135 */
2136 EMLXS_MSGF(EMLXS_CONTEXT, &emlxs_fcsp_detail_msg,
2066 did);
2067 }
2068
2069 if (ndlp) {
2070 if (pkt->pkt_state == FC_PKT_SUCCESS) {
2071 (void) emlxs_dhchap_state_machine(port, NULL, NULL,
2072 NULL, ndlp, NODE_EVENT_CMPL_AUTH_MSG);
2073 }

--- 45 unchanged lines hidden (view full) ---

2119 uint32_t tran_id;
2120 BIG_ERR_CODE err = BIG_OK;
2121
2122 /*
2123 * we assume the HBAnyware should configure the driver the right
2124 * parameters for challenge. for now, we create our own challenge.
2125 */
2126 EMLXS_MSGF(EMLXS_CONTEXT, &emlxs_fcsp_detail_msg,
2137 "emlxs_issue_dhchap_challenge: did=0x%x hashlist=[%x,%x,%x,%x]",
2127 "issue_dhchap_challenge: did=0x%x hashlist=[%x,%x,%x,%x]",
2138 ndlp->nlp_DID, node_dhc->auth_cfg.hash_priority[0],
2139 node_dhc->auth_cfg.hash_priority[1],
2140 node_dhc->auth_cfg.hash_priority[2],
2141 node_dhc->auth_cfg.hash_priority[3]);
2142
2143 /*
2144 * Here is my own challenge structure:
2145 *

--- 29 unchanged lines hidden (view full) ---

2175 break;
2176
2177 case GROUP_2048:
2178 cmdsize += 256;
2179 break;
2180
2181 default:
2182 EMLXS_MSGF(EMLXS_CONTEXT, &emlxs_fcsp_error_msg,
2128 ndlp->nlp_DID, node_dhc->auth_cfg.hash_priority[0],
2129 node_dhc->auth_cfg.hash_priority[1],
2130 node_dhc->auth_cfg.hash_priority[2],
2131 node_dhc->auth_cfg.hash_priority[3]);
2132
2133 /*
2134 * Here is my own challenge structure:
2135 *

--- 29 unchanged lines hidden (view full) ---

2165 break;
2166
2167 case GROUP_2048:
2168 cmdsize += 256;
2169 break;
2170
2171 default:
2172 EMLXS_MSGF(EMLXS_CONTEXT, &emlxs_fcsp_error_msg,
2183 "emlxs_issue_dhchap_challenge: Invalid dhgp_id=0x%x",
2173 "issue_dhchap_challenge: Invalid dhgp_id=0x%x",
2184 dhgp_id);
2185 return (1);
2186 }
2187
2188 cmd_size = cmdsize;
2189 rsp_size = 4;
2190
2191 if ((pkt = emlxs_prep_els_fc_pkt(port, ndlp->nlp_DID, cmd_size,

--- 4 unchanged lines hidden (view full) ---

2196 pCmd = (uint8_t *)pkt->pkt_cmd;
2197
2198 tmp = (uint8_t *)arg;
2199 tmp += 8;
2200 /* collect tran_id: this tran_id is set by the initiator */
2201 tran_id = *(uint32_t *)tmp;
2202
2203 EMLXS_MSGF(EMLXS_CONTEXT, &emlxs_fcsp_detail_msg,
2174 dhgp_id);
2175 return (1);
2176 }
2177
2178 cmd_size = cmdsize;
2179 rsp_size = 4;
2180
2181 if ((pkt = emlxs_prep_els_fc_pkt(port, ndlp->nlp_DID, cmd_size,

--- 4 unchanged lines hidden (view full) ---

2186 pCmd = (uint8_t *)pkt->pkt_cmd;
2187
2188 tmp = (uint8_t *)arg;
2189 tmp += 8;
2190 /* collect tran_id: this tran_id is set by the initiator */
2191 tran_id = *(uint32_t *)tmp;
2192
2193 EMLXS_MSGF(EMLXS_CONTEXT, &emlxs_fcsp_detail_msg,
2204 "emlxs_issue_dhchap_challenge: 0x%x 0x%x 0x%x %d 0x%x 0x%x 0x%x",
2194 "issue_dhchap_challenge: 0x%x 0x%x 0x%x %d 0x%x 0x%x 0x%x",
2205 ndlp->nlp_DID, node_dhc->nlp_auth_tranid_ini,
2206 node_dhc->nlp_auth_tranid_rsp,
2207 cmdsize, tran_id, hash_id, dhgp_id);
2208
2209 /* store the tran_id : ndlp is the initiator */
2210 node_dhc->nlp_auth_tranid_ini = LE_SWAP32(tran_id);
2211
2212 tmp += sizeof (uint32_t);

--- 160 unchanged lines hidden (view full) ---

2373 err = emlxs_BIGNUM_get_dhval(port, port_dhc, ndlp, dhval,
2374 &dhval_len, chal->cnul.dhgp_id,
2375 myrand, LE_SWAP32(chal->cnul.cval_len));
2376
2377 if (err != BIG_OK) {
2378 emlxs_pkt_free(pkt);
2379
2380 EMLXS_MSGF(EMLXS_CONTEXT, &emlxs_fcsp_error_msg,
2195 ndlp->nlp_DID, node_dhc->nlp_auth_tranid_ini,
2196 node_dhc->nlp_auth_tranid_rsp,
2197 cmdsize, tran_id, hash_id, dhgp_id);
2198
2199 /* store the tran_id : ndlp is the initiator */
2200 node_dhc->nlp_auth_tranid_ini = LE_SWAP32(tran_id);
2201
2202 tmp += sizeof (uint32_t);

--- 160 unchanged lines hidden (view full) ---

2363 err = emlxs_BIGNUM_get_dhval(port, port_dhc, ndlp, dhval,
2364 &dhval_len, chal->cnul.dhgp_id,
2365 myrand, LE_SWAP32(chal->cnul.cval_len));
2366
2367 if (err != BIG_OK) {
2368 emlxs_pkt_free(pkt);
2369
2370 EMLXS_MSGF(EMLXS_CONTEXT, &emlxs_fcsp_error_msg,
2381 "emlxs_issue_dhchap_challenge: error. 0x%x",
2371 "issue_dhchap_challenge: error. 0x%x",
2382 err);
2383
2384 return (1);
2385 }
2386 /* we are not going to use dhval and dhval_len */
2387
2388 /* *(uint32_t *)tmp = dhval_len; */
2389 if (ndlp->nlp_DID == FABRIC_DID) {
2390 *(uint32_t *)tmp =
2391 LE_SWAP32(node_dhc->hrsp_pubkey_len);
2392 } else {
2393 *(uint32_t *)tmp =
2394 LE_SWAP32(
2395 node_dhc->nlp_auth_misc.hrsp_pubkey_len);
2396 }
2397
2398 EMLXS_MSGF(EMLXS_CONTEXT, &emlxs_fcsp_detail_msg,
2372 err);
2373
2374 return (1);
2375 }
2376 /* we are not going to use dhval and dhval_len */
2377
2378 /* *(uint32_t *)tmp = dhval_len; */
2379 if (ndlp->nlp_DID == FABRIC_DID) {
2380 *(uint32_t *)tmp =
2381 LE_SWAP32(node_dhc->hrsp_pubkey_len);
2382 } else {
2383 *(uint32_t *)tmp =
2384 LE_SWAP32(
2385 node_dhc->nlp_auth_misc.hrsp_pubkey_len);
2386 }
2387
2388 EMLXS_MSGF(EMLXS_CONTEXT, &emlxs_fcsp_detail_msg,
2399 "emlxs_issue_dhchap_challenge: 0x%x: 0x%x 0x%x",
2389 "issue_dhchap_challenge: 0x%x: 0x%x 0x%x",
2400 ndlp->nlp_DID, *(uint32_t *)tmp, dhval_len);
2401
2402 tmp += sizeof (uint32_t);
2403
2404 if (ndlp->nlp_DID == FABRIC_DID) {
2405 bcopy((void *) node_dhc->hrsp_pub_key, (void *)tmp,
2406 node_dhc->hrsp_pubkey_len);
2407 } else {

--- 14 unchanged lines hidden (view full) ---

2422 if (dhgp_id != GROUP_NULL) {
2423
2424 err = emlxs_BIGNUM_get_dhval(port, port_dhc, ndlp, dhval,
2425 &dhval_len, chal->cnul.dhgp_id,
2426 random_number, LE_SWAP32(chal->cnul.cval_len));
2427
2428 if (err != BIG_OK) {
2429 EMLXS_MSGF(EMLXS_CONTEXT, &emlxs_fcsp_error_msg,
2390 ndlp->nlp_DID, *(uint32_t *)tmp, dhval_len);
2391
2392 tmp += sizeof (uint32_t);
2393
2394 if (ndlp->nlp_DID == FABRIC_DID) {
2395 bcopy((void *) node_dhc->hrsp_pub_key, (void *)tmp,
2396 node_dhc->hrsp_pubkey_len);
2397 } else {

--- 14 unchanged lines hidden (view full) ---

2412 if (dhgp_id != GROUP_NULL) {
2413
2414 err = emlxs_BIGNUM_get_dhval(port, port_dhc, ndlp, dhval,
2415 &dhval_len, chal->cnul.dhgp_id,
2416 random_number, LE_SWAP32(chal->cnul.cval_len));
2417
2418 if (err != BIG_OK) {
2419 EMLXS_MSGF(EMLXS_CONTEXT, &emlxs_fcsp_error_msg,
2430 "emlxs_issue_dhchap_challenge: error. 0x%x",
2420 "issue_dhchap_challenge: error. 0x%x",
2431 err);
2432
2433 emlxs_pkt_free(pkt);
2434 return (1);
2435 }
2436 /* we are not going to use dhval and dhval_len */
2437
2438 /* *(uint32_t *)tmp = dhval_len; */
2439 if (ndlp->nlp_DID == FABRIC_DID) {
2440 *(uint32_t *)tmp =
2441 LE_SWAP32(node_dhc->hrsp_pubkey_len);
2442 } else {
2443 *(uint32_t *)tmp =
2444 LE_SWAP32(
2445 node_dhc->nlp_auth_misc.hrsp_pubkey_len);
2446 }
2447
2448 EMLXS_MSGF(EMLXS_CONTEXT, &emlxs_fcsp_detail_msg,
2421 err);
2422
2423 emlxs_pkt_free(pkt);
2424 return (1);
2425 }
2426 /* we are not going to use dhval and dhval_len */
2427
2428 /* *(uint32_t *)tmp = dhval_len; */
2429 if (ndlp->nlp_DID == FABRIC_DID) {
2430 *(uint32_t *)tmp =
2431 LE_SWAP32(node_dhc->hrsp_pubkey_len);
2432 } else {
2433 *(uint32_t *)tmp =
2434 LE_SWAP32(
2435 node_dhc->nlp_auth_misc.hrsp_pubkey_len);
2436 }
2437
2438 EMLXS_MSGF(EMLXS_CONTEXT, &emlxs_fcsp_detail_msg,
2449 "emlxs_issue_dhchap_challenge: did=0x%x: pubkey_len=0x%x",
2439 "issue_dhchap_challenge: did=0x%x: pubkey_len=0x%x",
2450 ndlp->nlp_DID, *(uint32_t *)tmp);
2451
2452 tmp += sizeof (uint32_t);
2453
2454 if (ndlp->nlp_DID == FABRIC_DID) {
2455 bcopy((void *) node_dhc->hrsp_pub_key, (void *)tmp,
2456 node_dhc->hrsp_pubkey_len);
2457 } else {

--- 4 unchanged lines hidden (view full) ---

2462 } else {
2463 /* NULL DHCHAP */
2464 *(uint32_t *)tmp = 0;
2465 }
2466
2467#endif /* RAND */
2468
2469 EMLXS_MSGF(EMLXS_CONTEXT, &emlxs_fcsp_detail_msg,
2440 ndlp->nlp_DID, *(uint32_t *)tmp);
2441
2442 tmp += sizeof (uint32_t);
2443
2444 if (ndlp->nlp_DID == FABRIC_DID) {
2445 bcopy((void *) node_dhc->hrsp_pub_key, (void *)tmp,
2446 node_dhc->hrsp_pubkey_len);
2447 } else {

--- 4 unchanged lines hidden (view full) ---

2452 } else {
2453 /* NULL DHCHAP */
2454 *(uint32_t *)tmp = 0;
2455 }
2456
2457#endif /* RAND */
2458
2459 EMLXS_MSGF(EMLXS_CONTEXT, &emlxs_fcsp_detail_msg,
2470 "emlxs_issue_dhchap_challenge: 0x%x 0x%x 0x%x 0x%x 0x%x",
2460 "issue_dhchap_challenge: 0x%x 0x%x 0x%x 0x%x 0x%x",
2471 ndlp->nlp_DID, node_dhc->nlp_auth_tranid_ini,
2472 node_dhc->nlp_auth_tranid_rsp,
2473 chal->cnul.hash_id, chal->cnul.dhgp_id);
2474
2475 EMLXS_MSGF(EMLXS_CONTEXT, &emlxs_fcsp_detail_msg,
2461 ndlp->nlp_DID, node_dhc->nlp_auth_tranid_ini,
2462 node_dhc->nlp_auth_tranid_rsp,
2463 chal->cnul.hash_id, chal->cnul.dhgp_id);
2464
2465 EMLXS_MSGF(EMLXS_CONTEXT, &emlxs_fcsp_detail_msg,
2476 "emlxs_issue_dhchap_challenge: 0x%x 0x%x 0x%x 0x%x",
2466 "issue_dhchap_challenge: 0x%x 0x%x 0x%x 0x%x",
2477 ndlp->nlp_DID, tran_id, node_dhc->nlp_auth_hashid,
2478 node_dhc->nlp_auth_dhgpid);
2479
2480 pkt->pkt_comp = emlxs_cmpl_dhchap_challenge_issue;
2481
2482 if (emlxs_pkt_send(pkt, 1) != FC_SUCCESS) {
2483 emlxs_pkt_free(pkt);
2484
2485 EMLXS_MSGF(EMLXS_CONTEXT, &emlxs_fcsp_error_msg,
2467 ndlp->nlp_DID, tran_id, node_dhc->nlp_auth_hashid,
2468 node_dhc->nlp_auth_dhgpid);
2469
2470 pkt->pkt_comp = emlxs_cmpl_dhchap_challenge_issue;
2471
2472 if (emlxs_pkt_send(pkt, 1) != FC_SUCCESS) {
2473 emlxs_pkt_free(pkt);
2474
2475 EMLXS_MSGF(EMLXS_CONTEXT, &emlxs_fcsp_error_msg,
2486 "emlxs_issue_dhchap_challenge: Unable to send fc packet.");
2476 "issue_dhchap_challenge: Unable to send fc packet.");
2487
2488 return (1);
2489 }
2490 return (0);
2491
2492} /* emlxs_issue_dhchap_challenge */
2493
2494

--- 73 unchanged lines hidden (view full) ---

2568 }
2569
2570 cmd_size = cmdsize;
2571 rsp_size = 4;
2572
2573 if ((pkt = emlxs_prep_els_fc_pkt(port, ndlp->nlp_DID, cmd_size,
2574 rsp_size, 0, KM_NOSLEEP)) == NULL) {
2575 EMLXS_MSGF(EMLXS_CONTEXT, &emlxs_fcsp_error_msg,
2477
2478 return (1);
2479 }
2480 return (0);
2481
2482} /* emlxs_issue_dhchap_challenge */
2483
2484

--- 73 unchanged lines hidden (view full) ---

2558 }
2559
2560 cmd_size = cmdsize;
2561 rsp_size = 4;
2562
2563 if ((pkt = emlxs_prep_els_fc_pkt(port, ndlp->nlp_DID, cmd_size,
2564 rsp_size, 0, KM_NOSLEEP)) == NULL) {
2565 EMLXS_MSGF(EMLXS_CONTEXT, &emlxs_fcsp_error_msg,
2576 "emlxs_issue_dhchap_reply failed: did=0x%x size=%x,%x",
2566 "issue_dhchap_reply failed: did=0x%x size=%x,%x",
2577 ndlp->nlp_DID, cmd_size, rsp_size);
2578
2579 return (1);
2580 }
2581 pCmd = (uint8_t *)pkt->pkt_cmd;
2582
2583 ap = (DHCHAP_REPLY_HDR *)pCmd;
2584 ap->auth_els_code = ELS_CMD_AUTH_CODE;

--- 101 unchanged lines hidden (view full) ---

2686 bcopy((void *)arg2, (void *)pCmd, arg2_len);
2687 }
2688 }
2689 }
2690
2691 pkt->pkt_comp = emlxs_cmpl_dhchap_reply_issue;
2692
2693 EMLXS_MSGF(EMLXS_CONTEXT, &emlxs_fcsp_detail_msg,
2567 ndlp->nlp_DID, cmd_size, rsp_size);
2568
2569 return (1);
2570 }
2571 pCmd = (uint8_t *)pkt->pkt_cmd;
2572
2573 ap = (DHCHAP_REPLY_HDR *)pCmd;
2574 ap->auth_els_code = ELS_CMD_AUTH_CODE;

--- 101 unchanged lines hidden (view full) ---

2676 bcopy((void *)arg2, (void *)pCmd, arg2_len);
2677 }
2678 }
2679 }
2680
2681 pkt->pkt_comp = emlxs_cmpl_dhchap_reply_issue;
2682
2683 EMLXS_MSGF(EMLXS_CONTEXT, &emlxs_fcsp_detail_msg,
2694 "emlxs_issue_dhchap_reply: did=0x%x (%x,%x,%x,%x,%x,%x)",
2684 "issue_dhchap_reply: did=0x%x (%x,%x,%x,%x,%x,%x)",
2695 ndlp->nlp_DID, dhval_len, arg2_len, cmdsize,
2696 node_dhc->hash_id, node_dhc->nlp_auth_hashid,
2697 LE_SWAP32(ap->tran_id));
2698
2699 if (emlxs_pkt_send(pkt, 1) != FC_SUCCESS) {
2700 EMLXS_MSGF(EMLXS_CONTEXT, &emlxs_fcsp_error_msg,
2685 ndlp->nlp_DID, dhval_len, arg2_len, cmdsize,
2686 node_dhc->hash_id, node_dhc->nlp_auth_hashid,
2687 LE_SWAP32(ap->tran_id));
2688
2689 if (emlxs_pkt_send(pkt, 1) != FC_SUCCESS) {
2690 EMLXS_MSGF(EMLXS_CONTEXT, &emlxs_fcsp_error_msg,
2701 "emlxs_issue_dhchap_reply failed: Unable to send packet.");
2691 "issue_dhchap_reply failed: Unable to send packet.");
2702
2703 emlxs_pkt_free(pkt);
2704
2705 return (1);
2706 }
2707 return (0);
2708
2709} /* emlxs_issue_dhchap_reply */

--- 52 unchanged lines hidden (view full) ---

2762 uint8_t random_number[20]; /* for both SHA1 and MD5 */
2763 uint32_t *arg5 = NULL; /* response */
2764 uint32_t tran_id; /* Transaction Identifier */
2765 uint32_t arg2len = 0; /* len of new challenge for bidir auth */
2766
2767 AUTH_RJT *rjt;
2768
2769 EMLXS_MSGF(EMLXS_CONTEXT, &emlxs_fcsp_detail_msg,
2692
2693 emlxs_pkt_free(pkt);
2694
2695 return (1);
2696 }
2697 return (0);
2698
2699} /* emlxs_issue_dhchap_reply */

--- 52 unchanged lines hidden (view full) ---

2752 uint8_t random_number[20]; /* for both SHA1 and MD5 */
2753 uint32_t *arg5 = NULL; /* response */
2754 uint32_t tran_id; /* Transaction Identifier */
2755 uint32_t arg2len = 0; /* len of new challenge for bidir auth */
2756
2757 AUTH_RJT *rjt;
2758
2759 EMLXS_MSGF(EMLXS_CONTEXT, &emlxs_fcsp_detail_msg,
2770 "emlxs_rcv_auth_msg_auth_negotiate_cmpl_wait4next: did=0x%x",
2760 "rcv_auth_msg_auth_negotiate_cmpl_wait4next: did=0x%x",
2771 ndlp->nlp_DID);
2772
2773 emlxs_dhc_state(port, ndlp, NODE_STATE_DHCHAP_REPLY_ISSUE, 0, 0);
2774
2775 (void) emlxs_els_reply(port, iocbq, ELS_CMD_ACC, ELS_CMD_AUTH, 0, 0);
2776
2777 bp = mp->virt;
2778 lp = (uint32_t *)bp;

--- 64 unchanged lines hidden (view full) ---

2843 ReasonCodeExplanation = AUTHEXP_AUTH_FAILED;
2844 break;
2845 }
2846
2847 goto AUTH_Reject;
2848 }
2849 if (ncval->msg_hdr.auth_msg_code != DHCHAP_CHALLENGE) {
2850 EMLXS_MSGF(EMLXS_CONTEXT, &emlxs_fcsp_error_msg,
2761 ndlp->nlp_DID);
2762
2763 emlxs_dhc_state(port, ndlp, NODE_STATE_DHCHAP_REPLY_ISSUE, 0, 0);
2764
2765 (void) emlxs_els_reply(port, iocbq, ELS_CMD_ACC, ELS_CMD_AUTH, 0, 0);
2766
2767 bp = mp->virt;
2768 lp = (uint32_t *)bp;

--- 64 unchanged lines hidden (view full) ---

2833 ReasonCodeExplanation = AUTHEXP_AUTH_FAILED;
2834 break;
2835 }
2836
2837 goto AUTH_Reject;
2838 }
2839 if (ncval->msg_hdr.auth_msg_code != DHCHAP_CHALLENGE) {
2840 EMLXS_MSGF(EMLXS_CONTEXT, &emlxs_fcsp_error_msg,
2851 "emlxs_rcv_auth_msg_auth_negotiate_cmpl_wait4next: 0x%x.%x",
2841 "rcv_auth_msg_auth_negotiate_cmpl_wait4next: 0x%x.%x",
2852 ndlp->nlp_DID, ncval->msg_hdr.auth_msg_code);
2853
2854 ReasonCode = AUTHRJT_FAILURE;
2855 ReasonCodeExplanation = AUTHEXP_BAD_PROTOCOL;
2856 goto AUTH_Reject;
2857 }
2858 tran_id = ncval->msg_hdr.tran_id;
2859

--- 53 unchanged lines hidden (view full) ---

2913 bcopy((void *)tmp, (void *)un_cval.sha1.val,
2914 sizeof (SHA1_CVAL));
2915 tmp += sizeof (SHA1_CVAL);
2916
2917 arg2len = SHA1_LEN;
2918
2919 } else {
2920 EMLXS_MSGF(EMLXS_CONTEXT, &emlxs_fcsp_error_msg,
2842 ndlp->nlp_DID, ncval->msg_hdr.auth_msg_code);
2843
2844 ReasonCode = AUTHRJT_FAILURE;
2845 ReasonCodeExplanation = AUTHEXP_BAD_PROTOCOL;
2846 goto AUTH_Reject;
2847 }
2848 tran_id = ncval->msg_hdr.tran_id;
2849

--- 53 unchanged lines hidden (view full) ---

2903 bcopy((void *)tmp, (void *)un_cval.sha1.val,
2904 sizeof (SHA1_CVAL));
2905 tmp += sizeof (SHA1_CVAL);
2906
2907 arg2len = SHA1_LEN;
2908
2909 } else {
2910 EMLXS_MSGF(EMLXS_CONTEXT, &emlxs_fcsp_error_msg,
2921 "emlxs_rcv_auth_msg_auth_negotiate_cmpl_wait4next: 0x%x %x",
2911 "rcv_auth_msg_auth_negotiate_cmpl_wait4next: 0x%x %x",
2922 ndlp->nlp_DID, ncval->hash_id);
2923
2924 ReasonCode = AUTHRJT_FAILURE;
2925 ReasonCodeExplanation = AUTHEXP_BAD_PAYLOAD;
2926 goto AUTH_Reject;
2927 }
2928
2929 /*

--- 225 unchanged lines hidden (view full) ---

3155/* MATCHMAP * mp, */ void *arg3,
3156/* NODELIST * ndlp */ void *arg4,
3157uint32_t evt)
3158{
3159 NODELIST *ndlp = (NODELIST *) arg4;
3160 emlxs_node_dhc_t *node_dhc = &ndlp->node_dhc;
3161
3162 EMLXS_MSGF(EMLXS_CONTEXT, &emlxs_fcsp_detail_msg,
2912 ndlp->nlp_DID, ncval->hash_id);
2913
2914 ReasonCode = AUTHRJT_FAILURE;
2915 ReasonCodeExplanation = AUTHEXP_BAD_PAYLOAD;
2916 goto AUTH_Reject;
2917 }
2918
2919 /*

--- 225 unchanged lines hidden (view full) ---

3145/* MATCHMAP * mp, */ void *arg3,
3146/* NODELIST * ndlp */ void *arg4,
3147uint32_t evt)
3148{
3149 NODELIST *ndlp = (NODELIST *) arg4;
3150 emlxs_node_dhc_t *node_dhc = &ndlp->node_dhc;
3151
3152 EMLXS_MSGF(EMLXS_CONTEXT, &emlxs_fcsp_detail_msg,
3163 "emlxs_cmpl_auth_msg_dhchap_reply_issue: did=0x%x",
3153 "cmpl_auth_msg_dhchap_reply_issue: did=0x%x",
3164 ndlp->nlp_DID);
3165
3166 /* start the emlxs_dhc_authrsp_timeout timer now */
3167 if (node_dhc->nlp_authrsp_tmo == 0) {
3168 node_dhc->nlp_authrsp_tmo = DRV_TIME +
3169 node_dhc->auth_cfg.authentication_timeout;
3170 }
3171 /*

--- 78 unchanged lines hidden (view full) ---

3250
3251 if (dh_success->auth_msg_code == AUTH_REJECT) {
3252 /* ACC it and retry etc. */
3253 auth_rjt = (AUTH_RJT *) dh_success;
3254 ReasonCode = auth_rjt->ReasonCode;
3255 ReasonCodeExplanation = auth_rjt->ReasonCodeExplanation;
3256
3257 EMLXS_MSGF(EMLXS_CONTEXT, &emlxs_fcsp_detail_msg,
3154 ndlp->nlp_DID);
3155
3156 /* start the emlxs_dhc_authrsp_timeout timer now */
3157 if (node_dhc->nlp_authrsp_tmo == 0) {
3158 node_dhc->nlp_authrsp_tmo = DRV_TIME +
3159 node_dhc->auth_cfg.authentication_timeout;
3160 }
3161 /*

--- 78 unchanged lines hidden (view full) ---

3240
3241 if (dh_success->auth_msg_code == AUTH_REJECT) {
3242 /* ACC it and retry etc. */
3243 auth_rjt = (AUTH_RJT *) dh_success;
3244 ReasonCode = auth_rjt->ReasonCode;
3245 ReasonCodeExplanation = auth_rjt->ReasonCodeExplanation;
3246
3247 EMLXS_MSGF(EMLXS_CONTEXT, &emlxs_fcsp_detail_msg,
3258 "emlxs_rcv_auth_msg_dhchap_reply_cmpl_wait4next: 0x%x.(%x,%x)",
3248 "rcv_auth_msg_dhchap_reply_cmpl_wait4next: 0x%x.(%x,%x)",
3259 ndlp->nlp_DID, ReasonCode, ReasonCodeExplanation);
3260
3261 switch (ReasonCode) {
3262 case AUTHRJT_LOGIC_ERR:
3263 switch (ReasonCodeExplanation) {
3264 case AUTHEXP_MECH_UNUSABLE:
3265 case AUTHEXP_DHGROUP_UNUSABLE:
3266 case AUTHEXP_HASHFUNC_UNUSABLE:

--- 59 unchanged lines hidden (view full) ---

3326 goto AUTH_Reject;
3327 }
3328 if (node_dhc->auth_cfg.bidirectional == 0) {
3329 node_dhc->flag |=
3330 (NLP_REMOTE_AUTH | NLP_SET_REAUTH_TIME);
3331
3332 emlxs_dhc_state(port, ndlp,
3333 NODE_STATE_AUTH_SUCCESS, 0, 0);
3249 ndlp->nlp_DID, ReasonCode, ReasonCodeExplanation);
3250
3251 switch (ReasonCode) {
3252 case AUTHRJT_LOGIC_ERR:
3253 switch (ReasonCodeExplanation) {
3254 case AUTHEXP_MECH_UNUSABLE:
3255 case AUTHEXP_DHGROUP_UNUSABLE:
3256 case AUTHEXP_HASHFUNC_UNUSABLE:

--- 59 unchanged lines hidden (view full) ---

3316 goto AUTH_Reject;
3317 }
3318 if (node_dhc->auth_cfg.bidirectional == 0) {
3319 node_dhc->flag |=
3320 (NLP_REMOTE_AUTH | NLP_SET_REAUTH_TIME);
3321
3322 emlxs_dhc_state(port, ndlp,
3323 NODE_STATE_AUTH_SUCCESS, 0, 0);
3334 emlxs_log_auth_event(port, ndlp, ESC_EMLXS_20,
3324 emlxs_log_auth_event(port, ndlp,
3325 "rcv_auth_msg_dhchap_reply_cmpl_wait4next",
3335 "Host-initiated-unidir-auth-success");
3336 emlxs_dhc_auth_complete(port, ndlp, 0);
3337 } else {
3338 /* bidir auth needed */
3339 /* if (LE_SWAP32(dh_success->msg_len) > 4) { */
3340
3341 tmp = (uint8_t *)((uint8_t *)lp);
3342 tmp += 8;

--- 47 unchanged lines hidden (view full) ---

3390 hash_val = emlxs_hash_vrf(port, port_dhc, ndlp,
3391 tran_id, un_cval);
3392
3393 if (bcmp((void *)tmp, (void *)hash_val,
3394 LE_SWAP32(rsp_size))) {
3395 if (hash_val != NULL) {
3396 /* not identical */
3397 EMLXS_MSGF(EMLXS_CONTEXT, &emlxs_fcsp_detail_msg,
3326 "Host-initiated-unidir-auth-success");
3327 emlxs_dhc_auth_complete(port, ndlp, 0);
3328 } else {
3329 /* bidir auth needed */
3330 /* if (LE_SWAP32(dh_success->msg_len) > 4) { */
3331
3332 tmp = (uint8_t *)((uint8_t *)lp);
3333 tmp += 8;

--- 47 unchanged lines hidden (view full) ---

3381 hash_val = emlxs_hash_vrf(port, port_dhc, ndlp,
3382 tran_id, un_cval);
3383
3384 if (bcmp((void *)tmp, (void *)hash_val,
3385 LE_SWAP32(rsp_size))) {
3386 if (hash_val != NULL) {
3387 /* not identical */
3388 EMLXS_MSGF(EMLXS_CONTEXT, &emlxs_fcsp_detail_msg,
3398 "emlxs_rcv_auth_msg_dhchap_reply_cmpl_wait4next: 0x%x.failed. %x",
3389 "rcv_auth_msg_dhchap_reply_cmpl_wait4next: 0x%x.failed. %x",
3399 ndlp->nlp_DID, *(uint32_t *)hash_val);
3400 }
3401 ReasonCode = AUTHRJT_FAILURE;
3402 ReasonCodeExplanation = AUTHEXP_AUTH_FAILED;
3403 goto AUTH_Reject;
3404 }
3405 emlxs_dhc_state(port, ndlp,
3406 NODE_STATE_DHCHAP_SUCCESS_ISSUE_WAIT4NEXT, 0, 0);

--- 9 unchanged lines hidden (view full) ---

3416 emlxs_dhc_state(port, ndlp, NODE_STATE_AUTH_FAILED,
3417 ReasonCode, ReasonCodeExplanation);
3418 (void) emlxs_issue_auth_reject(port, ndlp, 0, 0, ReasonCode,
3419 ReasonCodeExplanation);
3420 emlxs_dhc_auth_complete(port, ndlp, 1);
3421
3422 return (node_dhc->state);
3423out:
3390 ndlp->nlp_DID, *(uint32_t *)hash_val);
3391 }
3392 ReasonCode = AUTHRJT_FAILURE;
3393 ReasonCodeExplanation = AUTHEXP_AUTH_FAILED;
3394 goto AUTH_Reject;
3395 }
3396 emlxs_dhc_state(port, ndlp,
3397 NODE_STATE_DHCHAP_SUCCESS_ISSUE_WAIT4NEXT, 0, 0);

--- 9 unchanged lines hidden (view full) ---

3407 emlxs_dhc_state(port, ndlp, NODE_STATE_AUTH_FAILED,
3408 ReasonCode, ReasonCodeExplanation);
3409 (void) emlxs_issue_auth_reject(port, ndlp, 0, 0, ReasonCode,
3410 ReasonCodeExplanation);
3411 emlxs_dhc_auth_complete(port, ndlp, 1);
3412
3413 return (node_dhc->state);
3414out:
3424 (void) sprintf(info,
3415 (void) snprintf(info, sizeof (info),
3425 "Auth Failed: ReasonCode=0x%x, ReasonCodeExplanation=0x%x",
3426 ReasonCode, ReasonCodeExplanation);
3427
3416 "Auth Failed: ReasonCode=0x%x, ReasonCodeExplanation=0x%x",
3417 ReasonCode, ReasonCodeExplanation);
3418
3428 emlxs_log_auth_event(port, ndlp, ESC_EMLXS_20, info);
3419 emlxs_log_auth_event(port, ndlp,
3420 "rcv_auth_msg_dhchap_reply_cmpl_wait4next", info);
3429 emlxs_dhc_auth_complete(port, ndlp, 1);
3430
3431 return (node_dhc->state);
3432
3433} /* emlxs_rcv_auth_msg_dhchap_reply_cmpl_wait4next */
3434
3435
3436

--- 97 unchanged lines hidden (view full) ---

3534 * uni-directional auth. Anyway we start host side reauth heart beat
3535 * timer now.
3536 */
3537
3538 node_dhc->flag &= ~NLP_REMOTE_AUTH;
3539 node_dhc->flag |= NLP_SET_REAUTH_TIME;
3540
3541 emlxs_dhc_state(port, ndlp, NODE_STATE_AUTH_SUCCESS, 0, 0);
3421 emlxs_dhc_auth_complete(port, ndlp, 1);
3422
3423 return (node_dhc->state);
3424
3425} /* emlxs_rcv_auth_msg_dhchap_reply_cmpl_wait4next */
3426
3427
3428

--- 97 unchanged lines hidden (view full) ---

3526 * uni-directional auth. Anyway we start host side reauth heart beat
3527 * timer now.
3528 */
3529
3530 node_dhc->flag &= ~NLP_REMOTE_AUTH;
3531 node_dhc->flag |= NLP_SET_REAUTH_TIME;
3532
3533 emlxs_dhc_state(port, ndlp, NODE_STATE_AUTH_SUCCESS, 0, 0);
3542 emlxs_log_auth_event(port, ndlp, ESC_EMLXS_25,
3534 emlxs_log_auth_event(port, ndlp,
3535 "cmpl_auth_msg_dhchap_success_issue_wait4next",
3543 "Host-initiated-bidir-auth-success");
3544 emlxs_dhc_auth_complete(port, ndlp, 0);
3545
3546 return (node_dhc->state);
3547
3548} /* emlxs_cmpl_auth_msg_dhchap_success_issue_wait4next */
3549
3550

--- 487 unchanged lines hidden (view full) ---

4038
4039 /* start the emlxs_dhc_authrsp_timeout timer */
4040 node_dhc->nlp_authrsp_tmo = DRV_TIME +
4041 node_dhc->auth_cfg.authentication_timeout;
4042 } else {
4043 node_dhc->flag &= ~NLP_REMOTE_AUTH;
4044
4045 emlxs_dhc_state(port, ndlp, NODE_STATE_AUTH_SUCCESS, 0, 0);
3536 "Host-initiated-bidir-auth-success");
3537 emlxs_dhc_auth_complete(port, ndlp, 0);
3538
3539 return (node_dhc->state);
3540
3541} /* emlxs_cmpl_auth_msg_dhchap_success_issue_wait4next */
3542
3543

--- 487 unchanged lines hidden (view full) ---

4031
4032 /* start the emlxs_dhc_authrsp_timeout timer */
4033 node_dhc->nlp_authrsp_tmo = DRV_TIME +
4034 node_dhc->auth_cfg.authentication_timeout;
4035 } else {
4036 node_dhc->flag &= ~NLP_REMOTE_AUTH;
4037
4038 emlxs_dhc_state(port, ndlp, NODE_STATE_AUTH_SUCCESS, 0, 0);
4046 emlxs_log_auth_event(port, ndlp, ESC_EMLXS_22,
4039 emlxs_log_auth_event(port, ndlp,
4040 "cmpl_auth_msg_dhchap_success_issue",
4047 "Node-initiated-unidir-reauth-success");
4048 emlxs_dhc_auth_complete(port, ndlp, 0);
4049 }
4050
4051 return (node_dhc->state);
4052
4053} /* emlxs_cmpl_auth_msg_dhchap_success_issue */
4054

--- 6 unchanged lines hidden (view full) ---

4061 void *arg2,
4062 void *arg3,
4063 void *arg4,
4064 uint32_t evt)
4065{
4066 NODELIST *ndlp = (NODELIST *)arg4;
4067
4068 EMLXS_MSGF(EMLXS_CONTEXT, &emlxs_fcsp_error_msg,
4041 "Node-initiated-unidir-reauth-success");
4042 emlxs_dhc_auth_complete(port, ndlp, 0);
4043 }
4044
4045 return (node_dhc->state);
4046
4047} /* emlxs_cmpl_auth_msg_dhchap_success_issue */
4048

--- 6 unchanged lines hidden (view full) ---

4055 void *arg2,
4056 void *arg3,
4057 void *arg4,
4058 uint32_t evt)
4059{
4060 NODELIST *ndlp = (NODELIST *)arg4;
4061
4062 EMLXS_MSGF(EMLXS_CONTEXT, &emlxs_fcsp_error_msg,
4069 "emlxs_device_recov_unmapped_node called. 0x%x. Not implemented.",
4063 "device_recov_unmapped_node called. 0x%x. Not implemented.",
4070 ndlp->nlp_DID);
4071
4072 return (0);
4073
4074} /* emlxs_device_recov_unmapped_node */
4075
4076
4077

--- 5 unchanged lines hidden (view full) ---

4083 void *arg2,
4084 void *arg3,
4085 void *arg4,
4086 uint32_t evt)
4087{
4088 NODELIST *ndlp = (NODELIST *)arg4;
4089
4090 EMLXS_MSGF(EMLXS_CONTEXT, &emlxs_fcsp_error_msg,
4064 ndlp->nlp_DID);
4065
4066 return (0);
4067
4068} /* emlxs_device_recov_unmapped_node */
4069
4070
4071

--- 5 unchanged lines hidden (view full) ---

4077 void *arg2,
4078 void *arg3,
4079 void *arg4,
4080 uint32_t evt)
4081{
4082 NODELIST *ndlp = (NODELIST *)arg4;
4083
4084 EMLXS_MSGF(EMLXS_CONTEXT, &emlxs_fcsp_error_msg,
4091 "emlxs_device_rm_npr_node called. 0x%x. Not implemented.",
4085 "device_rm_npr_node called. 0x%x. Not implemented.",
4092 ndlp->nlp_DID);
4093
4094 return (0);
4095
4096} /* emlxs_device_rm_npr_node */
4097
4098
4099/* ARGSUSED */

--- 4 unchanged lines hidden (view full) ---

4104 void *arg2,
4105 void *arg3,
4106 void *arg4,
4107 uint32_t evt)
4108{
4109 NODELIST *ndlp = (NODELIST *)arg4;
4110
4111 EMLXS_MSGF(EMLXS_CONTEXT, &emlxs_fcsp_error_msg,
4086 ndlp->nlp_DID);
4087
4088 return (0);
4089
4090} /* emlxs_device_rm_npr_node */
4091
4092
4093/* ARGSUSED */

--- 4 unchanged lines hidden (view full) ---

4098 void *arg2,
4099 void *arg3,
4100 void *arg4,
4101 uint32_t evt)
4102{
4103 NODELIST *ndlp = (NODELIST *)arg4;
4104
4105 EMLXS_MSGF(EMLXS_CONTEXT, &emlxs_fcsp_error_msg,
4112 "emlxs_device_recov_npr_node called. 0x%x. Not implemented.",
4106 "device_recov_npr_node called. 0x%x. Not implemented.",
4113 ndlp->nlp_DID);
4114
4115 return (0);
4116
4117} /* emlxs_device_recov_npr_node */
4118
4119
4120/* ARGSUSED */

--- 5 unchanged lines hidden (view full) ---

4126/* MATCHMAP * mp, */ void *arg3,
4127/* NODELIST * ndlp */ void *arg4,
4128uint32_t evt)
4129{
4130 NODELIST *ndlp = (NODELIST *)arg4;
4131 emlxs_node_dhc_t *node_dhc = &ndlp->node_dhc;
4132
4133 EMLXS_MSGF(EMLXS_CONTEXT, &emlxs_fcsp_detail_msg,
4107 ndlp->nlp_DID);
4108
4109 return (0);
4110
4111} /* emlxs_device_recov_npr_node */
4112
4113
4114/* ARGSUSED */

--- 5 unchanged lines hidden (view full) ---

4120/* MATCHMAP * mp, */ void *arg3,
4121/* NODELIST * ndlp */ void *arg4,
4122uint32_t evt)
4123{
4124 NODELIST *ndlp = (NODELIST *)arg4;
4125 emlxs_node_dhc_t *node_dhc = &ndlp->node_dhc;
4126
4127 EMLXS_MSGF(EMLXS_CONTEXT, &emlxs_fcsp_detail_msg,
4134 "emlxs_device_rem_auth: 0x%x.",
4128 "device_rem_auth: 0x%x.",
4135 ndlp->nlp_DID);
4136
4137 emlxs_dhc_state(port, ndlp, NODE_STATE_UNKNOWN, 0, 0);
4138
4139 return (node_dhc->state);
4140
4141} /* emlxs_device_rem_auth */
4142

--- 10 unchanged lines hidden (view full) ---

4153/* MATCHMAP * mp, */ void *arg3,
4154/* NODELIST * ndlp */ void *arg4,
4155uint32_t evt)
4156{
4157 NODELIST *ndlp = (NODELIST *)arg4;
4158 emlxs_node_dhc_t *node_dhc = &ndlp->node_dhc;
4159
4160 EMLXS_MSGF(EMLXS_CONTEXT, &emlxs_fcsp_detail_msg,
4129 ndlp->nlp_DID);
4130
4131 emlxs_dhc_state(port, ndlp, NODE_STATE_UNKNOWN, 0, 0);
4132
4133 return (node_dhc->state);
4134
4135} /* emlxs_device_rem_auth */
4136

--- 10 unchanged lines hidden (view full) ---

4147/* MATCHMAP * mp, */ void *arg3,
4148/* NODELIST * ndlp */ void *arg4,
4149uint32_t evt)
4150{
4151 NODELIST *ndlp = (NODELIST *)arg4;
4152 emlxs_node_dhc_t *node_dhc = &ndlp->node_dhc;
4153
4154 EMLXS_MSGF(EMLXS_CONTEXT, &emlxs_fcsp_detail_msg,
4161 "emlxs_device_recov_auth: 0x%x.",
4155 "device_recov_auth: 0x%x.",
4162 ndlp->nlp_DID);
4163
4164 node_dhc->nlp_authrsp_tmo = 0;
4165
4166 emlxs_dhc_state(port, ndlp, NODE_STATE_AUTH_FAILED, 0, 0);
4167
4168 return (node_dhc->state);
4169

--- 30 unchanged lines hidden (view full) ---

4200 AUTH_RJT *auth_rjt;
4201 uint8_t ReasonCode;
4202 uint8_t ReasonCodeExplanation;
4203
4204 bp = mp->virt;
4205 lp = (uint32_t *)bp;
4206
4207 EMLXS_MSGF(EMLXS_CONTEXT, &emlxs_fcsp_detail_msg,
4156 ndlp->nlp_DID);
4157
4158 node_dhc->nlp_authrsp_tmo = 0;
4159
4160 emlxs_dhc_state(port, ndlp, NODE_STATE_AUTH_FAILED, 0, 0);
4161
4162 return (node_dhc->state);
4163

--- 30 unchanged lines hidden (view full) ---

4194 AUTH_RJT *auth_rjt;
4195 uint8_t ReasonCode;
4196 uint8_t ReasonCodeExplanation;
4197
4198 bp = mp->virt;
4199 lp = (uint32_t *)bp;
4200
4201 EMLXS_MSGF(EMLXS_CONTEXT, &emlxs_fcsp_detail_msg,
4208 "emlxs_rcv_auth_msg_dhchap_success_cmpl_wait4next: did=0x%x",
4202 "rcv_auth_msg_dhchap_success_cmpl_wait4next: did=0x%x",
4209 ndlp->nlp_DID);
4210
4211 dh_success = (DHCHAP_SUCCESS_HDR *)((uint8_t *)lp);
4212
4213 (void) emlxs_els_reply(port, iocbq, ELS_CMD_ACC, ELS_CMD_AUTH, 0, 0);
4214
4215 if (dh_success->auth_msg_code == AUTH_REJECT) {
4216 /* ACC it and retry etc. */

--- 59 unchanged lines hidden (view full) ---

4276
4277 ReasonCode = AUTHRJT_FAILURE;
4278 ReasonCodeExplanation = AUTHEXP_BAD_PROTOCOL;
4279 goto Reject;
4280 }
4281 node_dhc->flag |= NLP_REMOTE_AUTH;
4282
4283 emlxs_dhc_state(port, ndlp, NODE_STATE_AUTH_SUCCESS, 0, 0);
4203 ndlp->nlp_DID);
4204
4205 dh_success = (DHCHAP_SUCCESS_HDR *)((uint8_t *)lp);
4206
4207 (void) emlxs_els_reply(port, iocbq, ELS_CMD_ACC, ELS_CMD_AUTH, 0, 0);
4208
4209 if (dh_success->auth_msg_code == AUTH_REJECT) {
4210 /* ACC it and retry etc. */

--- 59 unchanged lines hidden (view full) ---

4270
4271 ReasonCode = AUTHRJT_FAILURE;
4272 ReasonCodeExplanation = AUTHEXP_BAD_PROTOCOL;
4273 goto Reject;
4274 }
4275 node_dhc->flag |= NLP_REMOTE_AUTH;
4276
4277 emlxs_dhc_state(port, ndlp, NODE_STATE_AUTH_SUCCESS, 0, 0);
4284 emlxs_log_auth_event(port, ndlp, ESC_EMLXS_26,
4278 emlxs_log_auth_event(port, ndlp,
4279 "rcv_auth_msg_dhchap_success_cmpl_wait4next",
4285 "Node-initiated-bidir-reauth-success");
4286 emlxs_dhc_auth_complete(port, ndlp, 0);
4287 } else {
4288 ReasonCode = AUTHRJT_FAILURE;
4289 ReasonCodeExplanation = AUTHEXP_BAD_PROTOCOL;
4290 goto Reject;
4291 }
4292

--- 79 unchanged lines hidden (view full) ---

4372 uint32_t hash_id, dhgp_id; /* to be used by responder */
4373 uint16_t num_hs = 0;
4374 uint16_t num_dh = 0;
4375
4376 bp = mp->virt;
4377 lp = (uint32_t *)bp;
4378
4379 EMLXS_MSGF(EMLXS_CONTEXT, &emlxs_fcsp_detail_msg,
4280 "Node-initiated-bidir-reauth-success");
4281 emlxs_dhc_auth_complete(port, ndlp, 0);
4282 } else {
4283 ReasonCode = AUTHRJT_FAILURE;
4284 ReasonCodeExplanation = AUTHEXP_BAD_PROTOCOL;
4285 goto Reject;
4286 }
4287

--- 79 unchanged lines hidden (view full) ---

4367 uint32_t hash_id, dhgp_id; /* to be used by responder */
4368 uint16_t num_hs = 0;
4369 uint16_t num_dh = 0;
4370
4371 bp = mp->virt;
4372 lp = (uint32_t *)bp;
4373
4374 EMLXS_MSGF(EMLXS_CONTEXT, &emlxs_fcsp_detail_msg,
4380 "emlxs_rcv_auth_msg_npr_node:");
4375 "rcv_auth_msg_npr_node:");
4381
4382 /*
4383 * 1. process the auth msg, should acc first no matter what. 2.
4384 * return DHCHAP_Challenge for AUTH_Negotiate auth msg, AUTH_Reject
4385 * for anything else.
4386 */
4387 (void) emlxs_els_reply(port, iocbq, ELS_CMD_ACC, ELS_CMD_AUTH, 0, 0);
4388

--- 4 unchanged lines hidden (view full) ---

4393 /* temp is used for error checking */
4394 temp = (uint8_t *)((uint8_t *)lp);
4395 /* Check the auth_els_code */
4396 if (((*(uint32_t *)temp) & 0xFFFFFFFF) != LE_SWAP32(0x90000B01)) {
4397 /* ReasonCode = AUTHRJT_FAILURE; */
4398 /* ReasonCodeExplanation = AUTHEXP_BAD_PAYLOAD; */
4399
4400 EMLXS_MSGF(EMLXS_CONTEXT, &emlxs_fcsp_error_msg,
4376
4377 /*
4378 * 1. process the auth msg, should acc first no matter what. 2.
4379 * return DHCHAP_Challenge for AUTH_Negotiate auth msg, AUTH_Reject
4380 * for anything else.
4381 */
4382 (void) emlxs_els_reply(port, iocbq, ELS_CMD_ACC, ELS_CMD_AUTH, 0, 0);
4383

--- 4 unchanged lines hidden (view full) ---

4388 /* temp is used for error checking */
4389 temp = (uint8_t *)((uint8_t *)lp);
4390 /* Check the auth_els_code */
4391 if (((*(uint32_t *)temp) & 0xFFFFFFFF) != LE_SWAP32(0x90000B01)) {
4392 /* ReasonCode = AUTHRJT_FAILURE; */
4393 /* ReasonCodeExplanation = AUTHEXP_BAD_PAYLOAD; */
4394
4395 EMLXS_MSGF(EMLXS_CONTEXT, &emlxs_fcsp_error_msg,
4401 "emlxs_rcv_auth_msg_npr_node: payload(1)=0x%x",
4396 "rcv_auth_msg_npr_node: payload(1)=0x%x",
4402 (*(uint32_t *)temp));
4403
4404 goto AUTH_Reject;
4405 }
4406 temp += 3 * sizeof (uint32_t);
4407 /* Check name tag and name length */
4408 if (((*(uint32_t *)temp) & 0xFFFFFFFF) != LE_SWAP32(0x00010008)) {
4409 /* ReasonCode = AUTHRJT_FAILURE; */
4410 /* ReasonCodeExplanation = AUTHEXP_BAD_PAYLOAD; */
4411
4412 EMLXS_MSGF(EMLXS_CONTEXT, &emlxs_fcsp_error_msg,
4397 (*(uint32_t *)temp));
4398
4399 goto AUTH_Reject;
4400 }
4401 temp += 3 * sizeof (uint32_t);
4402 /* Check name tag and name length */
4403 if (((*(uint32_t *)temp) & 0xFFFFFFFF) != LE_SWAP32(0x00010008)) {
4404 /* ReasonCode = AUTHRJT_FAILURE; */
4405 /* ReasonCodeExplanation = AUTHEXP_BAD_PAYLOAD; */
4406
4407 EMLXS_MSGF(EMLXS_CONTEXT, &emlxs_fcsp_error_msg,
4413 "emlxs_rcv_auth_msg_npr_node: payload(2)=0x%x",
4408 "rcv_auth_msg_npr_node: payload(2)=0x%x",
4414 (*(uint32_t *)temp));
4415
4416 goto AUTH_Reject;
4417 }
4418 temp += sizeof (uint32_t) + 8;
4419 /* Check proto_num */
4420 if (((*(uint32_t *)temp) & 0xFFFFFFFF) != LE_SWAP32(0x00000001)) {
4421 /* ReasonCode = AUTHRJT_FAILURE; */
4422 /* ReasonCodeExplanation = AUTHEXP_BAD_PAYLOAD; */
4423
4424 EMLXS_MSGF(EMLXS_CONTEXT, &emlxs_fcsp_error_msg,
4409 (*(uint32_t *)temp));
4410
4411 goto AUTH_Reject;
4412 }
4413 temp += sizeof (uint32_t) + 8;
4414 /* Check proto_num */
4415 if (((*(uint32_t *)temp) & 0xFFFFFFFF) != LE_SWAP32(0x00000001)) {
4416 /* ReasonCode = AUTHRJT_FAILURE; */
4417 /* ReasonCodeExplanation = AUTHEXP_BAD_PAYLOAD; */
4418
4419 EMLXS_MSGF(EMLXS_CONTEXT, &emlxs_fcsp_error_msg,
4425 "emlxs_rcv_auth_msg_npr_node: payload(3)=0x%x",
4420 "rcv_auth_msg_npr_node: payload(3)=0x%x",
4426 (*(uint32_t *)temp));
4427
4428 goto AUTH_Reject;
4429 }
4430 temp += sizeof (uint32_t);
4431 /* Get para_len */
4432 /* para_len = LE_SWAP32(*(uint32_t *)temp); */
4433
4434 temp += sizeof (uint32_t);
4435 /* Check proto_id */
4436 if (((*(uint32_t *)temp) & 0xFFFFFFFF) != AUTH_DHCHAP) {
4437 /* ReasonCode = AUTHRJT_FAILURE; */
4438 /* ReasonCodeExplanation = AUTHEXP_BAD_PROTOCOL; */
4439
4440 EMLXS_MSGF(EMLXS_CONTEXT, &emlxs_fcsp_error_msg,
4421 (*(uint32_t *)temp));
4422
4423 goto AUTH_Reject;
4424 }
4425 temp += sizeof (uint32_t);
4426 /* Get para_len */
4427 /* para_len = LE_SWAP32(*(uint32_t *)temp); */
4428
4429 temp += sizeof (uint32_t);
4430 /* Check proto_id */
4431 if (((*(uint32_t *)temp) & 0xFFFFFFFF) != AUTH_DHCHAP) {
4432 /* ReasonCode = AUTHRJT_FAILURE; */
4433 /* ReasonCodeExplanation = AUTHEXP_BAD_PROTOCOL; */
4434
4435 EMLXS_MSGF(EMLXS_CONTEXT, &emlxs_fcsp_error_msg,
4441 "emlxs_rcv_auth_msg_npr_node: payload(4)=0x%x",
4436 "rcv_auth_msg_npr_node: payload(4)=0x%x",
4442 (*(uint32_t *)temp));
4443
4444 goto AUTH_Reject;
4445 }
4446 temp += sizeof (uint32_t);
4447 /* Check hashlist tag */
4448 if ((LE_SWAP32(*(uint32_t *)temp) & 0xFFFF0000) >> 16 !=
4449 LE_SWAP16(HASH_LIST_TAG)) {
4450 /* ReasonCode = AUTHRJT_FAILURE; */
4451 /* ReasonCodeExplanation = AUTHEXP_BAD_PAYLOAD; */
4452
4453 EMLXS_MSGF(EMLXS_CONTEXT, &emlxs_fcsp_error_msg,
4437 (*(uint32_t *)temp));
4438
4439 goto AUTH_Reject;
4440 }
4441 temp += sizeof (uint32_t);
4442 /* Check hashlist tag */
4443 if ((LE_SWAP32(*(uint32_t *)temp) & 0xFFFF0000) >> 16 !=
4444 LE_SWAP16(HASH_LIST_TAG)) {
4445 /* ReasonCode = AUTHRJT_FAILURE; */
4446 /* ReasonCodeExplanation = AUTHEXP_BAD_PAYLOAD; */
4447
4448 EMLXS_MSGF(EMLXS_CONTEXT, &emlxs_fcsp_error_msg,
4454 "emlxs_rcv_auth_msg_npr_node: payload(5)=0x%x",
4449 "rcv_auth_msg_npr_node: payload(5)=0x%x",
4455 (LE_SWAP32(*(uint32_t *)temp) & 0xFFFF0000) >> 16);
4456
4457 goto AUTH_Reject;
4458 }
4459 /* Get num_hs */
4460 num_hs = LE_SWAP32(*(uint32_t *)temp) & 0x0000FFFF;
4461
4462 temp += sizeof (uint32_t);
4463 /* Check HashList_value1 */
4464 hs_id[0] = *(uint32_t *)temp;
4465
4466 if ((hs_id[0] != AUTH_MD5) && (hs_id[0] != AUTH_SHA1)) {
4467 /* ReasonCode = AUTHRJT_LOGIC_ERR; */
4468 /* ReasonCodeExplanation = AUTHEXP_HASHFUNC_UNUSABLE; */
4469
4470 EMLXS_MSGF(EMLXS_CONTEXT, &emlxs_fcsp_error_msg,
4450 (LE_SWAP32(*(uint32_t *)temp) & 0xFFFF0000) >> 16);
4451
4452 goto AUTH_Reject;
4453 }
4454 /* Get num_hs */
4455 num_hs = LE_SWAP32(*(uint32_t *)temp) & 0x0000FFFF;
4456
4457 temp += sizeof (uint32_t);
4458 /* Check HashList_value1 */
4459 hs_id[0] = *(uint32_t *)temp;
4460
4461 if ((hs_id[0] != AUTH_MD5) && (hs_id[0] != AUTH_SHA1)) {
4462 /* ReasonCode = AUTHRJT_LOGIC_ERR; */
4463 /* ReasonCodeExplanation = AUTHEXP_HASHFUNC_UNUSABLE; */
4464
4465 EMLXS_MSGF(EMLXS_CONTEXT, &emlxs_fcsp_error_msg,
4471 "emlxs_rcv_auth_msg_npr_node: payload(6)=0x%x",
4466 "rcv_auth_msg_npr_node: payload(6)=0x%x",
4472 (*(uint32_t *)temp));
4473
4474 goto AUTH_Reject;
4475 }
4476 if (num_hs == 1) {
4477 hs_id[1] = 0;
4478 } else if (num_hs == 2) {
4479 temp += sizeof (uint32_t);
4480 hs_id[1] = *(uint32_t *)temp;
4481
4482 if ((hs_id[1] != AUTH_MD5) && (hs_id[1] != AUTH_SHA1)) {
4483 /* ReasonCode = AUTHRJT_LOGIC_ERR; */
4484 /* ReasonCodeExplanation = AUTHEXP_HASHFUNC_UNUSABLE; */
4485
4486 EMLXS_MSGF(EMLXS_CONTEXT, &emlxs_fcsp_error_msg,
4467 (*(uint32_t *)temp));
4468
4469 goto AUTH_Reject;
4470 }
4471 if (num_hs == 1) {
4472 hs_id[1] = 0;
4473 } else if (num_hs == 2) {
4474 temp += sizeof (uint32_t);
4475 hs_id[1] = *(uint32_t *)temp;
4476
4477 if ((hs_id[1] != AUTH_MD5) && (hs_id[1] != AUTH_SHA1)) {
4478 /* ReasonCode = AUTHRJT_LOGIC_ERR; */
4479 /* ReasonCodeExplanation = AUTHEXP_HASHFUNC_UNUSABLE; */
4480
4481 EMLXS_MSGF(EMLXS_CONTEXT, &emlxs_fcsp_error_msg,
4487 "emlxs_rcv_auth_msg_npr_node: payload(7)=0x%x",
4482 "rcv_auth_msg_npr_node: payload(7)=0x%x",
4488 (*(uint32_t *)temp));
4489
4490 goto AUTH_Reject;
4491 }
4492 if (hs_id[0] == hs_id[1]) {
4493 /* ReasonCode = AUTHRJT_FAILURE; */
4494 /* ReasonCodeExplanation = AUTHEXP_BAD_PAYLOAD; */
4495
4496 EMLXS_MSGF(EMLXS_CONTEXT, &emlxs_fcsp_error_msg,
4483 (*(uint32_t *)temp));
4484
4485 goto AUTH_Reject;
4486 }
4487 if (hs_id[0] == hs_id[1]) {
4488 /* ReasonCode = AUTHRJT_FAILURE; */
4489 /* ReasonCodeExplanation = AUTHEXP_BAD_PAYLOAD; */
4490
4491 EMLXS_MSGF(EMLXS_CONTEXT, &emlxs_fcsp_error_msg,
4497 "emlxs_rcv_auth_msg_npr_node: payload(8)=0x%x",
4492 "rcv_auth_msg_npr_node: payload(8)=0x%x",
4498 (*(uint32_t *)temp));
4499
4500 goto AUTH_Reject;
4501 }
4502 } else {
4503 /* ReasonCode = AUTHRJT_FAILURE; */
4504 /* ReasonCodeExplanation = AUTHEXP_BAD_PAYLOAD; */
4505
4506 EMLXS_MSGF(EMLXS_CONTEXT, &emlxs_fcsp_error_msg,
4493 (*(uint32_t *)temp));
4494
4495 goto AUTH_Reject;
4496 }
4497 } else {
4498 /* ReasonCode = AUTHRJT_FAILURE; */
4499 /* ReasonCodeExplanation = AUTHEXP_BAD_PAYLOAD; */
4500
4501 EMLXS_MSGF(EMLXS_CONTEXT, &emlxs_fcsp_error_msg,
4507 "emlxs_rcv_auth_msg_npr_node: payload(9)=0x%x",
4502 "rcv_auth_msg_npr_node: payload(9)=0x%x",
4508 (*(uint32_t *)(temp - sizeof (uint32_t))));
4509
4510 goto AUTH_Reject;
4511 }
4512
4513 /* Which hash_id should we use */
4514 if (num_hs == 1) {
4515 /*

--- 5 unchanged lines hidden (view full) ---

4521 hash_id = node_dhc->auth_cfg.hash_priority[0];
4522 } else if (node_dhc->auth_cfg.hash_priority[1] == hs_id[0]) {
4523 hash_id = node_dhc->auth_cfg.hash_priority[1];
4524 } else {
4525 /* ReasonCode = AUTHRJT_LOGIC_ERR; */
4526 /* ReasonCodeExplanation = AUTHEXP_HASHFUNC_UNUSABLE; */
4527
4528 EMLXS_MSGF(EMLXS_CONTEXT, &emlxs_fcsp_error_msg,
4503 (*(uint32_t *)(temp - sizeof (uint32_t))));
4504
4505 goto AUTH_Reject;
4506 }
4507
4508 /* Which hash_id should we use */
4509 if (num_hs == 1) {
4510 /*

--- 5 unchanged lines hidden (view full) ---

4516 hash_id = node_dhc->auth_cfg.hash_priority[0];
4517 } else if (node_dhc->auth_cfg.hash_priority[1] == hs_id[0]) {
4518 hash_id = node_dhc->auth_cfg.hash_priority[1];
4519 } else {
4520 /* ReasonCode = AUTHRJT_LOGIC_ERR; */
4521 /* ReasonCodeExplanation = AUTHEXP_HASHFUNC_UNUSABLE; */
4522
4523 EMLXS_MSGF(EMLXS_CONTEXT, &emlxs_fcsp_error_msg,
4529 "emlxs_rcv_auth_msg_npr_node: payload(10)=0x%lx",
4524 "rcv_auth_msg_npr_node: payload(10)=0x%lx",
4530 (*(uint32_t *)temp));
4531
4532 goto AUTH_Reject;
4533 }
4534 } else {
4535 /*
4536 * Since the initiator specified two hashs, we always select
4537 * our first one.

--- 4 unchanged lines hidden (view full) ---

4542 temp += sizeof (uint32_t);
4543 /* Check DHgIDList_tag */
4544 if ((LE_SWAP32(*(uint32_t *)temp) & 0xFFFF0000) >> 16 !=
4545 LE_SWAP16(DHGID_LIST_TAG)) {
4546 /* ReasonCode = AUTHRJT_FAILURE; */
4547 /* ReasonCodeExplanation = AUTHEXP_BAD_PAYLOAD; */
4548
4549 EMLXS_MSGF(EMLXS_CONTEXT, &emlxs_fcsp_error_msg,
4525 (*(uint32_t *)temp));
4526
4527 goto AUTH_Reject;
4528 }
4529 } else {
4530 /*
4531 * Since the initiator specified two hashs, we always select
4532 * our first one.

--- 4 unchanged lines hidden (view full) ---

4537 temp += sizeof (uint32_t);
4538 /* Check DHgIDList_tag */
4539 if ((LE_SWAP32(*(uint32_t *)temp) & 0xFFFF0000) >> 16 !=
4540 LE_SWAP16(DHGID_LIST_TAG)) {
4541 /* ReasonCode = AUTHRJT_FAILURE; */
4542 /* ReasonCodeExplanation = AUTHEXP_BAD_PAYLOAD; */
4543
4544 EMLXS_MSGF(EMLXS_CONTEXT, &emlxs_fcsp_error_msg,
4550 "emlxs_rcv_auth_msg_npr_node: payload(11)=0x%lx",
4545 "rcv_auth_msg_npr_node: payload(11)=0x%lx",
4551 (*(uint32_t *)temp));
4552
4553 goto AUTH_Reject;
4554 }
4555 /* Get num_dh */
4556 num_dh = LE_SWAP32(*(uint32_t *)temp) & 0x0000FFFF;
4557
4558 if (num_dh == 0) {
4559 /* ReasonCode = AUTHRJT_FAILURE; */
4560 /* ReasonCodeExplanation = AUTHEXP_BAD_PAYLOAD; */
4561
4562 EMLXS_MSGF(EMLXS_CONTEXT, &emlxs_fcsp_error_msg,
4546 (*(uint32_t *)temp));
4547
4548 goto AUTH_Reject;
4549 }
4550 /* Get num_dh */
4551 num_dh = LE_SWAP32(*(uint32_t *)temp) & 0x0000FFFF;
4552
4553 if (num_dh == 0) {
4554 /* ReasonCode = AUTHRJT_FAILURE; */
4555 /* ReasonCodeExplanation = AUTHEXP_BAD_PAYLOAD; */
4556
4557 EMLXS_MSGF(EMLXS_CONTEXT, &emlxs_fcsp_error_msg,
4563 "emlxs_rcv_auth_msg_npr_node: payload(12)=0x%lx",
4558 "rcv_auth_msg_npr_node: payload(12)=0x%lx",
4564 (*(uint32_t *)temp));
4565
4566 goto AUTH_Reject;
4567 }
4568 for (i = 0; i < num_dh; i++) {
4569 temp += sizeof (uint32_t);
4570 /* Check DHgIDList_g0 */
4571 dh_id[i] = (*(uint32_t *)temp);
4572 }
4573
4574 rc = emlxs_check_dhgp(port, ndlp, dh_id, num_dh, &dhgp_id);
4575
4576 if (rc == 1) {
4577 /* ReasonCode = AUTHRJT_LOGIC_ERR; */
4578 /* ReasonCodeExplanation = AUTHEXP_DHGROUP_UNUSABLE; */
4579
4580 EMLXS_MSGF(EMLXS_CONTEXT, &emlxs_fcsp_error_msg,
4559 (*(uint32_t *)temp));
4560
4561 goto AUTH_Reject;
4562 }
4563 for (i = 0; i < num_dh; i++) {
4564 temp += sizeof (uint32_t);
4565 /* Check DHgIDList_g0 */
4566 dh_id[i] = (*(uint32_t *)temp);
4567 }
4568
4569 rc = emlxs_check_dhgp(port, ndlp, dh_id, num_dh, &dhgp_id);
4570
4571 if (rc == 1) {
4572 /* ReasonCode = AUTHRJT_LOGIC_ERR; */
4573 /* ReasonCodeExplanation = AUTHEXP_DHGROUP_UNUSABLE; */
4574
4575 EMLXS_MSGF(EMLXS_CONTEXT, &emlxs_fcsp_error_msg,
4581 "emlxs_rcv_auth_msg_npr_node: payload(13)=0x%lx",
4576 "rcv_auth_msg_npr_node: payload(13)=0x%lx",
4582 (*(uint32_t *)temp));
4583
4584 goto AUTH_Reject;
4585 } else if (rc == 2) {
4586 /* ReasonCode = AUTHRJT_FAILURE; */
4587 /* ReasonCodeExplanation = AUTHEXP_BAD_PAYLOAD; */
4588
4589 EMLXS_MSGF(EMLXS_CONTEXT, &emlxs_fcsp_error_msg,
4577 (*(uint32_t *)temp));
4578
4579 goto AUTH_Reject;
4580 } else if (rc == 2) {
4581 /* ReasonCode = AUTHRJT_FAILURE; */
4582 /* ReasonCodeExplanation = AUTHEXP_BAD_PAYLOAD; */
4583
4584 EMLXS_MSGF(EMLXS_CONTEXT, &emlxs_fcsp_error_msg,
4590 "emlxs_rcv_auth_msg_npr_node: payload(14)=0x%lx",
4585 "rcv_auth_msg_npr_node: payload(14)=0x%lx",
4591 (*(uint32_t *)temp));
4592
4593 goto AUTH_Reject;
4594 }
4595 /* We should update the tran_id */
4596 node_dhc->nlp_auth_tranid_ini = msg->tran_id;
4597
4598 if (msg->auth_msg_code == AUTH_NEGOTIATE) {

--- 12 unchanged lines hidden (view full) ---

4611 goto AUTH_Reject;
4612 }
4613
4614 return (node_dhc->state);
4615
4616AUTH_Reject:
4617
4618 EMLXS_MSGF(EMLXS_CONTEXT, &emlxs_fcsp_detail_msg,
4586 (*(uint32_t *)temp));
4587
4588 goto AUTH_Reject;
4589 }
4590 /* We should update the tran_id */
4591 node_dhc->nlp_auth_tranid_ini = msg->tran_id;
4592
4593 if (msg->auth_msg_code == AUTH_NEGOTIATE) {

--- 12 unchanged lines hidden (view full) ---

4606 goto AUTH_Reject;
4607 }
4608
4609 return (node_dhc->state);
4610
4611AUTH_Reject:
4612
4613 EMLXS_MSGF(EMLXS_CONTEXT, &emlxs_fcsp_detail_msg,
4619 "emlxs_rcv_auth_msg_npr_node: AUTH_Reject it.");
4614 "rcv_auth_msg_npr_node: AUTH_Reject it.");
4620
4621 return (node_dhc->state);
4622
4623} /* emlxs_rcv_auth_msg_npr_node */
4624
4625
4626/* ARGSUSED */
4627static uint32_t

--- 11 unchanged lines hidden (view full) ---

4639 /*
4640 * we donot cancel the nodev timeout here because we donot know if we
4641 * can get the authentication restarted from other side once we got
4642 * the new auth transaction kicked off we cancel nodev tmo
4643 * immediately.
4644 */
4645 /* we goto change the hba state back to where it used to be */
4646 EMLXS_MSGF(EMLXS_CONTEXT, &emlxs_fcsp_detail_msg,
4615
4616 return (node_dhc->state);
4617
4618} /* emlxs_rcv_auth_msg_npr_node */
4619
4620
4621/* ARGSUSED */
4622static uint32_t

--- 11 unchanged lines hidden (view full) ---

4634 /*
4635 * we donot cancel the nodev timeout here because we donot know if we
4636 * can get the authentication restarted from other side once we got
4637 * the new auth transaction kicked off we cancel nodev tmo
4638 * immediately.
4639 */
4640 /* we goto change the hba state back to where it used to be */
4641 EMLXS_MSGF(EMLXS_CONTEXT, &emlxs_fcsp_detail_msg,
4647 "emlxs_cmpl_auth_msg_npr_node: 0x%x 0x%x prev_state=0x%x\n",
4642 "cmpl_auth_msg_npr_node: 0x%x 0x%x prev_state=0x%x\n",
4648 ndlp->nlp_DID, node_dhc->state, node_dhc->prev_state);
4649
4650 return (node_dhc->state);
4651
4652} /* emlxs_cmpl_auth_msg_npr_node */
4653
4654
4655/*

--- 59 unchanged lines hidden (view full) ---

4715 uint16_t num_dh = 0;
4716
4717 /*
4718 * 1. process the auth msg, should acc first no matter what. 2.
4719 * return DHCHAP_Challenge for AUTH_Negotiate auth msg, AUTH_Reject
4720 * for anything else.
4721 */
4722 EMLXS_MSGF(EMLXS_CONTEXT, &emlxs_fcsp_detail_msg,
4643 ndlp->nlp_DID, node_dhc->state, node_dhc->prev_state);
4644
4645 return (node_dhc->state);
4646
4647} /* emlxs_cmpl_auth_msg_npr_node */
4648
4649
4650/*

--- 59 unchanged lines hidden (view full) ---

4710 uint16_t num_dh = 0;
4711
4712 /*
4713 * 1. process the auth msg, should acc first no matter what. 2.
4714 * return DHCHAP_Challenge for AUTH_Negotiate auth msg, AUTH_Reject
4715 * for anything else.
4716 */
4717 EMLXS_MSGF(EMLXS_CONTEXT, &emlxs_fcsp_detail_msg,
4723 "emlxs_rcv_auth_msg_unmapped_node: Sending ACC: did=0x%x",
4718 "rcv_auth_msg_unmapped_node: Sending ACC: did=0x%x",
4724 ndlp->nlp_DID);
4725
4726 (void) emlxs_els_reply(port, iocbq, ELS_CMD_ACC, ELS_CMD_AUTH, 0, 0);
4727
4728 bp = mp->virt;
4729 lp = (uint32_t *)bp;
4730
4731 msg = (AUTH_MSG_HDR *)((uint8_t *)lp);

--- 4 unchanged lines hidden (view full) ---

4736 /* temp is used for error checking */
4737 temp = (uint8_t *)((uint8_t *)lp);
4738 /* Check the auth_els_code */
4739 if (((*(uint32_t *)temp) & 0xFFFFFFFF) != LE_SWAP32(0x90000B01)) {
4740 ReasonCode = AUTHRJT_FAILURE;
4741 ReasonCodeExplanation = AUTHEXP_BAD_PAYLOAD;
4742
4743 EMLXS_MSGF(EMLXS_CONTEXT, &emlxs_fcsp_detail_msg,
4719 ndlp->nlp_DID);
4720
4721 (void) emlxs_els_reply(port, iocbq, ELS_CMD_ACC, ELS_CMD_AUTH, 0, 0);
4722
4723 bp = mp->virt;
4724 lp = (uint32_t *)bp;
4725
4726 msg = (AUTH_MSG_HDR *)((uint8_t *)lp);

--- 4 unchanged lines hidden (view full) ---

4731 /* temp is used for error checking */
4732 temp = (uint8_t *)((uint8_t *)lp);
4733 /* Check the auth_els_code */
4734 if (((*(uint32_t *)temp) & 0xFFFFFFFF) != LE_SWAP32(0x90000B01)) {
4735 ReasonCode = AUTHRJT_FAILURE;
4736 ReasonCodeExplanation = AUTHEXP_BAD_PAYLOAD;
4737
4738 EMLXS_MSGF(EMLXS_CONTEXT, &emlxs_fcsp_detail_msg,
4744 "emlxs_rcv_auth_msg_unmapped_node: payload(1)=0x%x",
4739 "rcv_auth_msg_unmapped_node: payload(1)=0x%x",
4745 (*(uint32_t *)temp));
4746
4747 goto AUTH_Reject;
4748 }
4749 temp += 3 * sizeof (uint32_t);
4750 /* Check name tag and name length */
4751 if (((*(uint32_t *)temp) & 0xFFFFFFFF) != LE_SWAP32(0x00010008)) {
4752 ReasonCode = AUTHRJT_FAILURE;
4753 ReasonCodeExplanation = AUTHEXP_BAD_PAYLOAD;
4754
4755 EMLXS_MSGF(EMLXS_CONTEXT, &emlxs_fcsp_detail_msg,
4740 (*(uint32_t *)temp));
4741
4742 goto AUTH_Reject;
4743 }
4744 temp += 3 * sizeof (uint32_t);
4745 /* Check name tag and name length */
4746 if (((*(uint32_t *)temp) & 0xFFFFFFFF) != LE_SWAP32(0x00010008)) {
4747 ReasonCode = AUTHRJT_FAILURE;
4748 ReasonCodeExplanation = AUTHEXP_BAD_PAYLOAD;
4749
4750 EMLXS_MSGF(EMLXS_CONTEXT, &emlxs_fcsp_detail_msg,
4756 "emlxs_rcv_auth_msg_unmapped_node: payload(2)=0x%x",
4751 "rcv_auth_msg_unmapped_node: payload(2)=0x%x",
4757 (*(uint32_t *)temp));
4758
4759 goto AUTH_Reject;
4760 }
4761 temp += sizeof (uint32_t) + 8;
4762 /* Check proto_num */
4763 if (((*(uint32_t *)temp) & 0xFFFFFFFF) != LE_SWAP32(0x00000001)) {
4764 ReasonCode = AUTHRJT_FAILURE;
4765 ReasonCodeExplanation = AUTHEXP_BAD_PAYLOAD;
4766
4767 EMLXS_MSGF(EMLXS_CONTEXT, &emlxs_fcsp_detail_msg,
4752 (*(uint32_t *)temp));
4753
4754 goto AUTH_Reject;
4755 }
4756 temp += sizeof (uint32_t) + 8;
4757 /* Check proto_num */
4758 if (((*(uint32_t *)temp) & 0xFFFFFFFF) != LE_SWAP32(0x00000001)) {
4759 ReasonCode = AUTHRJT_FAILURE;
4760 ReasonCodeExplanation = AUTHEXP_BAD_PAYLOAD;
4761
4762 EMLXS_MSGF(EMLXS_CONTEXT, &emlxs_fcsp_detail_msg,
4768 "emlxs_rcv_auth_msg_unmapped_node: payload(3)=0x%x",
4763 "rcv_auth_msg_unmapped_node: payload(3)=0x%x",
4769 (*(uint32_t *)temp));
4770
4771 goto AUTH_Reject;
4772 }
4773 temp += sizeof (uint32_t);
4774
4775 /* Get para_len */
4776 /* para_len = *(uint32_t *)temp; */
4777 temp += sizeof (uint32_t);
4778
4779 /* Check proto_id */
4780 if (((*(uint32_t *)temp) & 0xFFFFFFFF) != AUTH_DHCHAP) {
4781 ReasonCode = AUTHRJT_FAILURE;
4782 ReasonCodeExplanation = AUTHEXP_BAD_PROTOCOL;
4783
4784 EMLXS_MSGF(EMLXS_CONTEXT, &emlxs_fcsp_detail_msg,
4764 (*(uint32_t *)temp));
4765
4766 goto AUTH_Reject;
4767 }
4768 temp += sizeof (uint32_t);
4769
4770 /* Get para_len */
4771 /* para_len = *(uint32_t *)temp; */
4772 temp += sizeof (uint32_t);
4773
4774 /* Check proto_id */
4775 if (((*(uint32_t *)temp) & 0xFFFFFFFF) != AUTH_DHCHAP) {
4776 ReasonCode = AUTHRJT_FAILURE;
4777 ReasonCodeExplanation = AUTHEXP_BAD_PROTOCOL;
4778
4779 EMLXS_MSGF(EMLXS_CONTEXT, &emlxs_fcsp_detail_msg,
4785 "emlxs_rcv_auth_msg_unmapped_node: payload(4)=0x%x",
4780 "rcv_auth_msg_unmapped_node: payload(4)=0x%x",
4786 (*(uint32_t *)temp));
4787
4788 goto AUTH_Reject;
4789 }
4790 temp += sizeof (uint32_t);
4791 /* Check hashlist tag */
4792 if ((LE_SWAP32(*(uint32_t *)temp) & 0xFFFF0000) >> 16 !=
4793 LE_SWAP16(HASH_LIST_TAG)) {
4794 ReasonCode = AUTHRJT_FAILURE;
4795 ReasonCodeExplanation = AUTHEXP_BAD_PAYLOAD;
4796
4797 EMLXS_MSGF(EMLXS_CONTEXT, &emlxs_fcsp_detail_msg,
4781 (*(uint32_t *)temp));
4782
4783 goto AUTH_Reject;
4784 }
4785 temp += sizeof (uint32_t);
4786 /* Check hashlist tag */
4787 if ((LE_SWAP32(*(uint32_t *)temp) & 0xFFFF0000) >> 16 !=
4788 LE_SWAP16(HASH_LIST_TAG)) {
4789 ReasonCode = AUTHRJT_FAILURE;
4790 ReasonCodeExplanation = AUTHEXP_BAD_PAYLOAD;
4791
4792 EMLXS_MSGF(EMLXS_CONTEXT, &emlxs_fcsp_detail_msg,
4798 "emlxs_rcv_auth_msg_unmapped_node: payload(5)=0x%x",
4793 "rcv_auth_msg_unmapped_node: payload(5)=0x%x",
4799 (LE_SWAP32(*(uint32_t *)temp) & 0xFFFF0000) >> 16);
4800
4801 goto AUTH_Reject;
4802 }
4803 /* Get num_hs */
4804 num_hs = LE_SWAP32(*(uint32_t *)temp) & 0x0000FFFF;
4805
4806 temp += sizeof (uint32_t);
4807 /* Check HashList_value1 */
4808 hs_id[0] = *(uint32_t *)temp;
4809
4810 if ((hs_id[0] != AUTH_MD5) && (hs_id[0] != AUTH_SHA1)) {
4811 ReasonCode = AUTHRJT_LOGIC_ERR;
4812 ReasonCodeExplanation = AUTHEXP_HASHFUNC_UNUSABLE;
4813
4814 EMLXS_MSGF(EMLXS_CONTEXT, &emlxs_fcsp_detail_msg,
4794 (LE_SWAP32(*(uint32_t *)temp) & 0xFFFF0000) >> 16);
4795
4796 goto AUTH_Reject;
4797 }
4798 /* Get num_hs */
4799 num_hs = LE_SWAP32(*(uint32_t *)temp) & 0x0000FFFF;
4800
4801 temp += sizeof (uint32_t);
4802 /* Check HashList_value1 */
4803 hs_id[0] = *(uint32_t *)temp;
4804
4805 if ((hs_id[0] != AUTH_MD5) && (hs_id[0] != AUTH_SHA1)) {
4806 ReasonCode = AUTHRJT_LOGIC_ERR;
4807 ReasonCodeExplanation = AUTHEXP_HASHFUNC_UNUSABLE;
4808
4809 EMLXS_MSGF(EMLXS_CONTEXT, &emlxs_fcsp_detail_msg,
4815 "emlxs_rcv_auth_msg_unmapped_node: payload(6)=0x%x",
4810 "rcv_auth_msg_unmapped_node: payload(6)=0x%x",
4816 (*(uint32_t *)temp));
4817
4818 goto AUTH_Reject;
4819 }
4820 if (num_hs == 1) {
4821 hs_id[1] = 0;
4822 } else if (num_hs == 2) {
4823 temp += sizeof (uint32_t);
4824 hs_id[1] = *(uint32_t *)temp;
4825
4826 if ((hs_id[1] != AUTH_MD5) && (hs_id[1] != AUTH_SHA1)) {
4827 ReasonCode = AUTHRJT_LOGIC_ERR;
4828 ReasonCodeExplanation = AUTHEXP_HASHFUNC_UNUSABLE;
4829
4830 EMLXS_MSGF(EMLXS_CONTEXT, &emlxs_fcsp_detail_msg,
4811 (*(uint32_t *)temp));
4812
4813 goto AUTH_Reject;
4814 }
4815 if (num_hs == 1) {
4816 hs_id[1] = 0;
4817 } else if (num_hs == 2) {
4818 temp += sizeof (uint32_t);
4819 hs_id[1] = *(uint32_t *)temp;
4820
4821 if ((hs_id[1] != AUTH_MD5) && (hs_id[1] != AUTH_SHA1)) {
4822 ReasonCode = AUTHRJT_LOGIC_ERR;
4823 ReasonCodeExplanation = AUTHEXP_HASHFUNC_UNUSABLE;
4824
4825 EMLXS_MSGF(EMLXS_CONTEXT, &emlxs_fcsp_detail_msg,
4831 "emlxs_rcv_auth_msg_unmapped_node: payload(7)=0x%x",
4826 "rcv_auth_msg_unmapped_node: payload(7)=0x%x",
4832 (*(uint32_t *)temp));
4833
4834 goto AUTH_Reject;
4835 }
4836 if (hs_id[0] == hs_id[1]) {
4837 ReasonCode = AUTHRJT_FAILURE;
4838 ReasonCodeExplanation = AUTHEXP_BAD_PAYLOAD;
4839
4840 EMLXS_MSGF(EMLXS_CONTEXT, &emlxs_fcsp_detail_msg,
4827 (*(uint32_t *)temp));
4828
4829 goto AUTH_Reject;
4830 }
4831 if (hs_id[0] == hs_id[1]) {
4832 ReasonCode = AUTHRJT_FAILURE;
4833 ReasonCodeExplanation = AUTHEXP_BAD_PAYLOAD;
4834
4835 EMLXS_MSGF(EMLXS_CONTEXT, &emlxs_fcsp_detail_msg,
4841 "emlxs_rcv_auth_msg_unmapped_node: payload(8)=0x%x",
4836 "rcv_auth_msg_unmapped_node: payload(8)=0x%x",
4842 (*(uint32_t *)temp));
4843
4844 goto AUTH_Reject;
4845 }
4846 } else {
4847 ReasonCode = AUTHRJT_FAILURE;
4848 ReasonCodeExplanation = AUTHEXP_BAD_PAYLOAD;
4849
4850 EMLXS_MSGF(EMLXS_CONTEXT, &emlxs_fcsp_detail_msg,
4837 (*(uint32_t *)temp));
4838
4839 goto AUTH_Reject;
4840 }
4841 } else {
4842 ReasonCode = AUTHRJT_FAILURE;
4843 ReasonCodeExplanation = AUTHEXP_BAD_PAYLOAD;
4844
4845 EMLXS_MSGF(EMLXS_CONTEXT, &emlxs_fcsp_detail_msg,
4851 "emlxs_rcv_auth_msg_unmapped_node: payload(9)=0x%x",
4846 "rcv_auth_msg_unmapped_node: payload(9)=0x%x",
4852 (*(uint32_t *)(temp - sizeof (uint32_t))));
4853
4854 goto AUTH_Reject;
4855 }
4856
4857 /* Which hash_id should we use */
4858 if (num_hs == 1) {
4859 /*

--- 5 unchanged lines hidden (view full) ---

4865 hash_id = node_dhc->auth_cfg.hash_priority[0];
4866 } else if (node_dhc->auth_cfg.hash_priority[1] == hs_id[0]) {
4867 hash_id = node_dhc->auth_cfg.hash_priority[1];
4868 } else {
4869 ReasonCode = AUTHRJT_LOGIC_ERR;
4870 ReasonCodeExplanation = AUTHEXP_HASHFUNC_UNUSABLE;
4871
4872 EMLXS_MSGF(EMLXS_CONTEXT, &emlxs_fcsp_detail_msg,
4847 (*(uint32_t *)(temp - sizeof (uint32_t))));
4848
4849 goto AUTH_Reject;
4850 }
4851
4852 /* Which hash_id should we use */
4853 if (num_hs == 1) {
4854 /*

--- 5 unchanged lines hidden (view full) ---

4860 hash_id = node_dhc->auth_cfg.hash_priority[0];
4861 } else if (node_dhc->auth_cfg.hash_priority[1] == hs_id[0]) {
4862 hash_id = node_dhc->auth_cfg.hash_priority[1];
4863 } else {
4864 ReasonCode = AUTHRJT_LOGIC_ERR;
4865 ReasonCodeExplanation = AUTHEXP_HASHFUNC_UNUSABLE;
4866
4867 EMLXS_MSGF(EMLXS_CONTEXT, &emlxs_fcsp_detail_msg,
4873 "emlxs_rcv_auth_msg_unmapped_node: pload(10)=0x%x",
4868 "rcv_auth_msg_unmapped_node: pload(10)=0x%x",
4874 (*(uint32_t *)temp));
4875
4876 goto AUTH_Reject;
4877 }
4878 } else {
4879 /*
4880 * Since the initiator specified two hashs, we always select
4881 * our first one.

--- 4 unchanged lines hidden (view full) ---

4886 temp += sizeof (uint32_t);
4887 /* Check DHgIDList_tag */
4888 if ((LE_SWAP32(*(uint32_t *)temp) & 0xFFFF0000) >> 16 !=
4889 LE_SWAP16(DHGID_LIST_TAG)) {
4890 ReasonCode = AUTHRJT_FAILURE;
4891 ReasonCodeExplanation = AUTHEXP_BAD_PAYLOAD;
4892
4893 EMLXS_MSGF(EMLXS_CONTEXT, &emlxs_fcsp_detail_msg,
4869 (*(uint32_t *)temp));
4870
4871 goto AUTH_Reject;
4872 }
4873 } else {
4874 /*
4875 * Since the initiator specified two hashs, we always select
4876 * our first one.

--- 4 unchanged lines hidden (view full) ---

4881 temp += sizeof (uint32_t);
4882 /* Check DHgIDList_tag */
4883 if ((LE_SWAP32(*(uint32_t *)temp) & 0xFFFF0000) >> 16 !=
4884 LE_SWAP16(DHGID_LIST_TAG)) {
4885 ReasonCode = AUTHRJT_FAILURE;
4886 ReasonCodeExplanation = AUTHEXP_BAD_PAYLOAD;
4887
4888 EMLXS_MSGF(EMLXS_CONTEXT, &emlxs_fcsp_detail_msg,
4894 "emlxs_rcv_auth_msg_unmapped_node: payload(11)=0x%x",
4889 "rcv_auth_msg_unmapped_node: payload(11)=0x%x",
4895 (*(uint32_t *)temp));
4896
4897 goto AUTH_Reject;
4898 }
4899 /* Get num_dh */
4900 num_dh = LE_SWAP32(*(uint32_t *)temp) & 0x0000FFFF;
4901
4902 if (num_dh == 0) {
4903 ReasonCode = AUTHRJT_FAILURE;
4904 ReasonCodeExplanation = AUTHEXP_BAD_PAYLOAD;
4905
4906 EMLXS_MSGF(EMLXS_CONTEXT, &emlxs_fcsp_detail_msg,
4890 (*(uint32_t *)temp));
4891
4892 goto AUTH_Reject;
4893 }
4894 /* Get num_dh */
4895 num_dh = LE_SWAP32(*(uint32_t *)temp) & 0x0000FFFF;
4896
4897 if (num_dh == 0) {
4898 ReasonCode = AUTHRJT_FAILURE;
4899 ReasonCodeExplanation = AUTHEXP_BAD_PAYLOAD;
4900
4901 EMLXS_MSGF(EMLXS_CONTEXT, &emlxs_fcsp_detail_msg,
4907 "emlxs_rcv_auth_msg_unmapped_node: payload(12)=0x%x",
4902 "rcv_auth_msg_unmapped_node: payload(12)=0x%x",
4908 (*(uint32_t *)temp));
4909
4910 goto AUTH_Reject;
4911 }
4912 for (i = 0; i < num_dh; i++) {
4913 temp += sizeof (uint32_t);
4914 /* Check DHgIDList_g0 */
4915 dh_id[i] = (*(uint32_t *)temp);
4916 }
4917
4918 rc = emlxs_check_dhgp(port, ndlp, dh_id, num_dh, &dhgp_id);
4919
4920 if (rc == 1) {
4921 ReasonCode = AUTHRJT_LOGIC_ERR;
4922 ReasonCodeExplanation = AUTHEXP_DHGROUP_UNUSABLE;
4923
4924 EMLXS_MSGF(EMLXS_CONTEXT, &emlxs_fcsp_detail_msg,
4903 (*(uint32_t *)temp));
4904
4905 goto AUTH_Reject;
4906 }
4907 for (i = 0; i < num_dh; i++) {
4908 temp += sizeof (uint32_t);
4909 /* Check DHgIDList_g0 */
4910 dh_id[i] = (*(uint32_t *)temp);
4911 }
4912
4913 rc = emlxs_check_dhgp(port, ndlp, dh_id, num_dh, &dhgp_id);
4914
4915 if (rc == 1) {
4916 ReasonCode = AUTHRJT_LOGIC_ERR;
4917 ReasonCodeExplanation = AUTHEXP_DHGROUP_UNUSABLE;
4918
4919 EMLXS_MSGF(EMLXS_CONTEXT, &emlxs_fcsp_detail_msg,
4925 "emlxs_rcv_auth_msg_unmapped_node: payload(13)=0x%x",
4920 "rcv_auth_msg_unmapped_node: payload(13)=0x%x",
4926 (*(uint32_t *)temp));
4927
4928 goto AUTH_Reject;
4929 } else if (rc == 2) {
4930 ReasonCode = AUTHRJT_FAILURE;
4931 ReasonCodeExplanation = AUTHEXP_BAD_PAYLOAD;
4932
4933 EMLXS_MSGF(EMLXS_CONTEXT, &emlxs_fcsp_detail_msg,
4921 (*(uint32_t *)temp));
4922
4923 goto AUTH_Reject;
4924 } else if (rc == 2) {
4925 ReasonCode = AUTHRJT_FAILURE;
4926 ReasonCodeExplanation = AUTHEXP_BAD_PAYLOAD;
4927
4928 EMLXS_MSGF(EMLXS_CONTEXT, &emlxs_fcsp_detail_msg,
4934 "emlxs_rcv_auth_msg_unmapped_node: payload(14)=0x%x",
4929 "rcv_auth_msg_unmapped_node: payload(14)=0x%x",
4935 (*(uint32_t *)temp));
4936
4937 goto AUTH_Reject;
4938 }
4939 EMLXS_MSGF(EMLXS_CONTEXT, &emlxs_fcsp_detail_msg,
4930 (*(uint32_t *)temp));
4931
4932 goto AUTH_Reject;
4933 }
4934 EMLXS_MSGF(EMLXS_CONTEXT, &emlxs_fcsp_detail_msg,
4940 "emlxs_rcv_auth_msg_unmapped_node: 0x%x 0x%x 0x%x 0x%x 0x%x",
4935 "rcv_auth_msg_unmapped_node: 0x%x 0x%x 0x%x 0x%x 0x%x",
4941 hash_id, dhgp_id, msg->auth_msg_code, msglen, msg->tran_id);
4942
4943 /*
4944 * since ndlp is the initiator, tran_id is store in
4945 * nlp_auth_tranid_ini
4946 */
4947 node_dhc->nlp_auth_tranid_ini = LE_SWAP32(msg->tran_id);
4948

--- 16 unchanged lines hidden (view full) ---

4965 * as the auth initiator, host should reply to the received
4966 * AUTH_Negotiate message with an AUTH_Reject message with
4967 * Reason Code 'Logical Error' and Reason Code Explanation
4968 * 'Authentication Transaction Already Started'.
4969 */
4970 if (node_dhc->nlp_reauth_status ==
4971 NLP_HOST_REAUTH_IN_PROGRESS) {
4972 EMLXS_MSGF(EMLXS_CONTEXT, &emlxs_fcsp_detail_msg,
4936 hash_id, dhgp_id, msg->auth_msg_code, msglen, msg->tran_id);
4937
4938 /*
4939 * since ndlp is the initiator, tran_id is store in
4940 * nlp_auth_tranid_ini
4941 */
4942 node_dhc->nlp_auth_tranid_ini = LE_SWAP32(msg->tran_id);
4943

--- 16 unchanged lines hidden (view full) ---

4960 * as the auth initiator, host should reply to the received
4961 * AUTH_Negotiate message with an AUTH_Reject message with
4962 * Reason Code 'Logical Error' and Reason Code Explanation
4963 * 'Authentication Transaction Already Started'.
4964 */
4965 if (node_dhc->nlp_reauth_status ==
4966 NLP_HOST_REAUTH_IN_PROGRESS) {
4967 EMLXS_MSGF(EMLXS_CONTEXT, &emlxs_fcsp_detail_msg,
4973 "emlxs_rcv_auth_msg_unmapped_node: Ht reauth inprgress.");
4968 "rcv_auth_msg_unmapped_node: Ht reauth inprgress.");
4974
4975 ReasonCode = AUTHRJT_LOGIC_ERR;
4976 ReasonCodeExplanation = AUTHEXP_AUTHTRAN_STARTED;
4977
4978 goto AUTH_Reject;
4979 }
4980 /* Send back the DHCHAP_Challenge with the proper paramaters */
4981 if (emlxs_issue_dhchap_challenge(port, ndlp, 0, tmp,

--- 66 unchanged lines hidden (view full) ---

5048 dhgp_id = node_dhc->dhgp_id;
5049 } else {
5050 remote_key = (char *)node_dhc->auth_key.remote_password;
5051 hash_id = node_dhc->nlp_auth_hashid;
5052 dhgp_id = node_dhc->nlp_auth_dhgpid;
5053 }
5054
5055 EMLXS_MSGF(EMLXS_CONTEXT, &emlxs_fcsp_detail_msg,
4969
4970 ReasonCode = AUTHRJT_LOGIC_ERR;
4971 ReasonCodeExplanation = AUTHEXP_AUTHTRAN_STARTED;
4972
4973 goto AUTH_Reject;
4974 }
4975 /* Send back the DHCHAP_Challenge with the proper paramaters */
4976 if (emlxs_issue_dhchap_challenge(port, ndlp, 0, tmp,

--- 66 unchanged lines hidden (view full) ---

5043 dhgp_id = node_dhc->dhgp_id;
5044 } else {
5045 remote_key = (char *)node_dhc->auth_key.remote_password;
5046 hash_id = node_dhc->nlp_auth_hashid;
5047 dhgp_id = node_dhc->nlp_auth_dhgpid;
5048 }
5049
5050 EMLXS_MSGF(EMLXS_CONTEXT, &emlxs_fcsp_detail_msg,
5056 "emlxs_hash_vrf: 0x%x 0x%x 0x%x tran_id=0x%x",
5051 "hash_vrf: 0x%x 0x%x 0x%x tran_id=0x%x",
5057 ndlp->nlp_DID, hash_id, dhgp_id, mytran_id);
5058
5059 if (dhgp_id == 0) {
5060 /* NULL DHCHAP */
5061 if (hash_id == AUTH_MD5) {
5062 bzero(&mdctx, sizeof (MD5_CTX));
5063
5064 hash_size = MD5_LEN;

--- 193 unchanged lines hidden (view full) ---

5258 hash_id = node_dhc->nlp_auth_hashid;
5259 dhgp_id = node_dhc->nlp_auth_dhgpid;
5260 }
5261
5262 tran_id = (AUTH_TRAN_ID_MASK & tran_id);
5263 mytran_id = (uint8_t)(LE_SWAP32(tran_id));
5264
5265 EMLXS_MSGF(EMLXS_CONTEXT, &emlxs_fcsp_detail_msg,
5052 ndlp->nlp_DID, hash_id, dhgp_id, mytran_id);
5053
5054 if (dhgp_id == 0) {
5055 /* NULL DHCHAP */
5056 if (hash_id == AUTH_MD5) {
5057 bzero(&mdctx, sizeof (MD5_CTX));
5058
5059 hash_size = MD5_LEN;

--- 193 unchanged lines hidden (view full) ---

5253 hash_id = node_dhc->nlp_auth_hashid;
5254 dhgp_id = node_dhc->nlp_auth_dhgpid;
5255 }
5256
5257 tran_id = (AUTH_TRAN_ID_MASK & tran_id);
5258 mytran_id = (uint8_t)(LE_SWAP32(tran_id));
5259
5260 EMLXS_MSGF(EMLXS_CONTEXT, &emlxs_fcsp_detail_msg,
5266 "emlxs_hash_rsp: 0x%x 0x%x 0x%x 0x%x dhvallen=0x%x",
5261 "hash_rsp: 0x%x 0x%x 0x%x 0x%x dhvallen=0x%x",
5267 ndlp->nlp_DID, hash_id, dhgp_id, mytran_id, dhvallen);
5268
5269 if (ndlp->nlp_DID == FABRIC_DID) {
5270 mykey = (char *)node_dhc->auth_key.local_password;
5271
5272 } else {
5273 mykey = (char *)node_dhc->auth_key.local_password;
5274 }

--- 283 unchanged lines hidden (view full) ---

5558 * compute a^e mod n assume a < n, n odd, result->value at least as
5559 * long as n->value.
5560 *
5561 * a is the public key received from responder. e is the private key
5562 * generated by me. n is the wellknown modulus.
5563 */
5564
5565 EMLXS_MSGF(EMLXS_CONTEXT, &emlxs_fcsp_detail_msg,
5262 ndlp->nlp_DID, hash_id, dhgp_id, mytran_id, dhvallen);
5263
5264 if (ndlp->nlp_DID == FABRIC_DID) {
5265 mykey = (char *)node_dhc->auth_key.local_password;
5266
5267 } else {
5268 mykey = (char *)node_dhc->auth_key.local_password;
5269 }

--- 283 unchanged lines hidden (view full) ---

5553 * compute a^e mod n assume a < n, n odd, result->value at least as
5554 * long as n->value.
5555 *
5556 * a is the public key received from responder. e is the private key
5557 * generated by me. n is the wellknown modulus.
5558 */
5559
5560 EMLXS_MSGF(EMLXS_CONTEXT, &emlxs_fcsp_detail_msg,
5566 "emlxs_BIGNUM_get_pubkey: 0x%x 0x%x 0x%x 0x%x",
5561 "BIGNUM_get_pubkey: 0x%x 0x%x 0x%x 0x%x",
5567 ndlp->nlp_DID, *dhvallen, hash_size, dhgp_id);
5568
5569 /* size should be in the unit of (BIG_CHUNK_TYPE) words */
5570 if (big_init(&a, CHARLEN2BIGNUMLEN(*dhvallen)) != BIG_OK) {
5571 EMLXS_MSGF(EMLXS_CONTEXT, &emlxs_fcsp_error_msg,
5562 ndlp->nlp_DID, *dhvallen, hash_size, dhgp_id);
5563
5564 /* size should be in the unit of (BIG_CHUNK_TYPE) words */
5565 if (big_init(&a, CHARLEN2BIGNUMLEN(*dhvallen)) != BIG_OK) {
5566 EMLXS_MSGF(EMLXS_CONTEXT, &emlxs_fcsp_error_msg,
5572 "emlxs_BIGNUM_get_pubkey: big_init failed. a size=%d",
5567 "BIGNUM_get_pubkey: big_init failed. a size=%d",
5573 CHARLEN2BIGNUMLEN(*dhvallen));
5574
5575 err = BIG_NO_MEM;
5576 return (err);
5577 }
5578 /* a: (g^x mod p) */
5579 /*
5580 * dhval is in big-endian format. This call converts from
5581 * byte-big-endian format to big number format (words in little
5582 * endian order, but bytes within the words big endian)
5583 */
5584 bytestring2bignum(&a, (unsigned char *)dhval, *dhvallen);
5585
5586 if (big_init(&e, CHARLEN2BIGNUMLEN(hash_size)) != BIG_OK) {
5587 EMLXS_MSGF(EMLXS_CONTEXT, &emlxs_fcsp_error_msg,
5568 CHARLEN2BIGNUMLEN(*dhvallen));
5569
5570 err = BIG_NO_MEM;
5571 return (err);
5572 }
5573 /* a: (g^x mod p) */
5574 /*
5575 * dhval is in big-endian format. This call converts from
5576 * byte-big-endian format to big number format (words in little
5577 * endian order, but bytes within the words big endian)
5578 */
5579 bytestring2bignum(&a, (unsigned char *)dhval, *dhvallen);
5580
5581 if (big_init(&e, CHARLEN2BIGNUMLEN(hash_size)) != BIG_OK) {
5582 EMLXS_MSGF(EMLXS_CONTEXT, &emlxs_fcsp_error_msg,
5588 "emlxs_BIGNUM_get_pubkey: big_init failed. e size=%d",
5583 "BIGNUM_get_pubkey: big_init failed. e size=%d",
5589 CHARLEN2BIGNUMLEN(hash_size));
5590
5591 err = BIG_NO_MEM;
5592 goto ret1;
5593 }
5594#ifdef RAND
5595
5596 bzero(&random_number, hash_size);

--- 42 unchanged lines hidden (view full) ---

5639 case GROUP_2048:
5640 plen = 256;
5641 tmp = dhgp4_pVal;
5642 break;
5643 }
5644
5645 if (big_init(&n, CHARLEN2BIGNUMLEN(plen)) != BIG_OK) {
5646 EMLXS_MSGF(EMLXS_CONTEXT, &emlxs_fcsp_error_msg,
5584 CHARLEN2BIGNUMLEN(hash_size));
5585
5586 err = BIG_NO_MEM;
5587 goto ret1;
5588 }
5589#ifdef RAND
5590
5591 bzero(&random_number, hash_size);

--- 42 unchanged lines hidden (view full) ---

5634 case GROUP_2048:
5635 plen = 256;
5636 tmp = dhgp4_pVal;
5637 break;
5638 }
5639
5640 if (big_init(&n, CHARLEN2BIGNUMLEN(plen)) != BIG_OK) {
5641 EMLXS_MSGF(EMLXS_CONTEXT, &emlxs_fcsp_error_msg,
5647 "emlxs_BIGNUM_get_pubkey: big_init failed. n size=%d",
5642 "BIGNUM_get_pubkey: big_init failed. n size=%d",
5648 CHARLEN2BIGNUMLEN(plen));
5649 err = BIG_NO_MEM;
5650 goto ret2;
5651 }
5652 bytestring2bignum(&n, (unsigned char *)tmp, plen);
5653
5654 if (big_init(&result, CHARLEN2BIGNUMLEN(512)) != BIG_OK) {
5655 EMLXS_MSGF(EMLXS_CONTEXT, &emlxs_fcsp_error_msg,
5643 CHARLEN2BIGNUMLEN(plen));
5644 err = BIG_NO_MEM;
5645 goto ret2;
5646 }
5647 bytestring2bignum(&n, (unsigned char *)tmp, plen);
5648
5649 if (big_init(&result, CHARLEN2BIGNUMLEN(512)) != BIG_OK) {
5650 EMLXS_MSGF(EMLXS_CONTEXT, &emlxs_fcsp_error_msg,
5656 "emlxs_BIGNUM_get_pubkey: big_init failed. result size=%d",
5651 "BIGNUM_get_pubkey: big_init failed. result size=%d",
5657 CHARLEN2BIGNUMLEN(512));
5658
5659 err = BIG_NO_MEM;
5660 goto ret3;
5661 }
5662 if (big_cmp_abs(&a, &n) > 0) {
5663 EMLXS_MSGF(EMLXS_CONTEXT, &emlxs_fcsp_error_msg,
5652 CHARLEN2BIGNUMLEN(512));
5653
5654 err = BIG_NO_MEM;
5655 goto ret3;
5656 }
5657 if (big_cmp_abs(&a, &n) > 0) {
5658 EMLXS_MSGF(EMLXS_CONTEXT, &emlxs_fcsp_error_msg,
5664 "emlxs_BIGNUM_get_pubkey: big_cmp_abs error.");
5659 "BIGNUM_get_pubkey: big_cmp_abs error.");
5665 err = BIG_GENERAL_ERR;
5666 goto ret4;
5667 }
5668 /* perform computation on big numbers to get seskey */
5669 /* a^e mod n */
5670 /* i.e., (g^x mod p)^y mod p */
5671
5672 if (big_modexp(&result, &a, &e, &n, NULL) != BIG_OK) {
5673 EMLXS_MSGF(EMLXS_CONTEXT, &emlxs_fcsp_error_msg,
5660 err = BIG_GENERAL_ERR;
5661 goto ret4;
5662 }
5663 /* perform computation on big numbers to get seskey */
5664 /* a^e mod n */
5665 /* i.e., (g^x mod p)^y mod p */
5666
5667 if (big_modexp(&result, &a, &e, &n, NULL) != BIG_OK) {
5668 EMLXS_MSGF(EMLXS_CONTEXT, &emlxs_fcsp_error_msg,
5674 "emlxs_BIGNUM_get_pubkey: big_modexp result error");
5669 "BIGNUM_get_pubkey: big_modexp result error");
5675 err = BIG_NO_MEM;
5676 goto ret4;
5677 }
5678 /* convert big number ses_key to bytestring */
5679 if (ndlp->nlp_DID == FABRIC_DID) {
5680 /*
5681 * This call converts from big number format to
5682 * byte-big-endian format. big number format is words in

--- 13 unchanged lines hidden (view full) ---

5696 /* for end-to-end auth */
5697 bignum2bytestring(node_dhc->nlp_auth_misc.ses_key, &result,
5698 sizeof (BIG_CHUNK_TYPE) * (result.len));
5699 node_dhc->nlp_auth_misc.seskey_len =
5700 sizeof (BIG_CHUNK_TYPE) * (result.len);
5701 }
5702
5703 EMLXS_MSGF(EMLXS_CONTEXT, &emlxs_fcsp_detail_msg,
5670 err = BIG_NO_MEM;
5671 goto ret4;
5672 }
5673 /* convert big number ses_key to bytestring */
5674 if (ndlp->nlp_DID == FABRIC_DID) {
5675 /*
5676 * This call converts from big number format to
5677 * byte-big-endian format. big number format is words in

--- 13 unchanged lines hidden (view full) ---

5691 /* for end-to-end auth */
5692 bignum2bytestring(node_dhc->nlp_auth_misc.ses_key, &result,
5693 sizeof (BIG_CHUNK_TYPE) * (result.len));
5694 node_dhc->nlp_auth_misc.seskey_len =
5695 sizeof (BIG_CHUNK_TYPE) * (result.len);
5696 }
5697
5698 EMLXS_MSGF(EMLXS_CONTEXT, &emlxs_fcsp_detail_msg,
5704 "emlxs_BIGNUM_get_pubkey: after seskey cal: 0x%x 0x%x 0x%x",
5699 "BIGNUM_get_pubkey: after seskey cal: 0x%x 0x%x 0x%x",
5705 node_dhc->nlp_auth_misc.seskey_len, result.size, result.len);
5706
5707
5708 /* to get pub_key: g^y mod p, g is 2 */
5709
5710 if (big_init(&g, 1) != BIG_OK) {
5711 EMLXS_MSGF(EMLXS_CONTEXT, &emlxs_fcsp_error_msg,
5700 node_dhc->nlp_auth_misc.seskey_len, result.size, result.len);
5701
5702
5703 /* to get pub_key: g^y mod p, g is 2 */
5704
5705 if (big_init(&g, 1) != BIG_OK) {
5706 EMLXS_MSGF(EMLXS_CONTEXT, &emlxs_fcsp_error_msg,
5712 "emlxs_BIGNUM_get_pubkey: big_init failed. g size=1");
5707 "BIGNUM_get_pubkey: big_init failed. g size=1");
5713
5714 err = BIG_NO_MEM;
5715 goto ret4;
5716 }
5717 if (big_init(&result1, CHARLEN2BIGNUMLEN(512)) != BIG_OK) {
5718 EMLXS_MSGF(EMLXS_CONTEXT, &emlxs_fcsp_error_msg,
5708
5709 err = BIG_NO_MEM;
5710 goto ret4;
5711 }
5712 if (big_init(&result1, CHARLEN2BIGNUMLEN(512)) != BIG_OK) {
5713 EMLXS_MSGF(EMLXS_CONTEXT, &emlxs_fcsp_error_msg,
5719 "emlxs_BIGNUM_get_pubkey: big_init failed. result1 size=%d",
5714 "BIGNUM_get_pubkey: big_init failed. result1 size=%d",
5720 CHARLEN2BIGNUMLEN(512));
5721 err = BIG_NO_MEM;
5722 goto ret5;
5723 }
5724
5725 bytestring2bignum(&g,
5726 (unsigned char *)&gen, sizeof (BIG_CHUNK_TYPE));
5727
5728 if (big_modexp(&result1, &g, &e, &n, NULL) != BIG_OK) {
5729 EMLXS_MSGF(EMLXS_CONTEXT, &emlxs_fcsp_error_msg,
5715 CHARLEN2BIGNUMLEN(512));
5716 err = BIG_NO_MEM;
5717 goto ret5;
5718 }
5719
5720 bytestring2bignum(&g,
5721 (unsigned char *)&gen, sizeof (BIG_CHUNK_TYPE));
5722
5723 if (big_modexp(&result1, &g, &e, &n, NULL) != BIG_OK) {
5724 EMLXS_MSGF(EMLXS_CONTEXT, &emlxs_fcsp_error_msg,
5730 "emlxs_BIGNUM_get_pubkey: big_modexp result1 error");
5725 "BIGNUM_get_pubkey: big_modexp result1 error");
5731 err = BIG_NO_MEM;
5732 goto ret6;
5733 }
5734 /* convert big number pub_key to bytestring */
5735 if (ndlp->nlp_DID == FABRIC_DID) {
5736
5737 bignum2bytestring(node_dhc->pub_key, &result1,
5738 sizeof (BIG_CHUNK_TYPE) * (result1.len));

--- 9 unchanged lines hidden (view full) ---

5748 /* for end-to-end auth */
5749 bignum2bytestring(node_dhc->nlp_auth_misc.pub_key, &result1,
5750 sizeof (BIG_CHUNK_TYPE) * (result1.len));
5751 node_dhc->nlp_auth_misc.pubkey_len =
5752 (result1.len) * sizeof (BIG_CHUNK_TYPE);
5753 }
5754
5755 EMLXS_MSGF(EMLXS_CONTEXT, &emlxs_fcsp_detail_msg,
5726 err = BIG_NO_MEM;
5727 goto ret6;
5728 }
5729 /* convert big number pub_key to bytestring */
5730 if (ndlp->nlp_DID == FABRIC_DID) {
5731
5732 bignum2bytestring(node_dhc->pub_key, &result1,
5733 sizeof (BIG_CHUNK_TYPE) * (result1.len));

--- 9 unchanged lines hidden (view full) ---

5743 /* for end-to-end auth */
5744 bignum2bytestring(node_dhc->nlp_auth_misc.pub_key, &result1,
5745 sizeof (BIG_CHUNK_TYPE) * (result1.len));
5746 node_dhc->nlp_auth_misc.pubkey_len =
5747 (result1.len) * sizeof (BIG_CHUNK_TYPE);
5748 }
5749
5750 EMLXS_MSGF(EMLXS_CONTEXT, &emlxs_fcsp_detail_msg,
5756 "emlxs_BIGNUM_get_pubkey: after pubkey cal: 0x%x 0x%x 0x%x",
5751 "BIGNUM_get_pubkey: after pubkey cal: 0x%x 0x%x 0x%x",
5757 node_dhc->nlp_auth_misc.pubkey_len, result1.size, result1.len);
5758
5759
5760ret6:
5761 big_finish(&result1);
5762ret5:
5763 big_finish(&g);
5764ret4:

--- 34 unchanged lines hidden (view full) ---

5799 uint8_t gen[] = {0x00, 0x00, 0x00, 0x02};
5800#else
5801 uint8_t gen[] = {0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02};
5802#endif /* BIGNUM_CHUNK_32 */
5803
5804 BIG_ERR_CODE err = BIG_OK;
5805
5806 EMLXS_MSGF(EMLXS_CONTEXT, &emlxs_fcsp_detail_msg,
5752 node_dhc->nlp_auth_misc.pubkey_len, result1.size, result1.len);
5753
5754
5755ret6:
5756 big_finish(&result1);
5757ret5:
5758 big_finish(&g);
5759ret4:

--- 34 unchanged lines hidden (view full) ---

5794 uint8_t gen[] = {0x00, 0x00, 0x00, 0x02};
5795#else
5796 uint8_t gen[] = {0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02};
5797#endif /* BIGNUM_CHUNK_32 */
5798
5799 BIG_ERR_CODE err = BIG_OK;
5800
5801 EMLXS_MSGF(EMLXS_CONTEXT, &emlxs_fcsp_detail_msg,
5807 "emlxs_BIGNUM_get_dhval: did=0x%x privkey_len=0x%x dhgp_id=0x%x",
5802 "BIGNUM_get_dhval: did=0x%x privkey_len=0x%x dhgp_id=0x%x",
5808 ndlp->nlp_DID, privkey_len, dhgp_id);
5809
5810 if (big_init(&result1, CHARLEN2BIGNUMLEN(512)) != BIG_OK) {
5811 EMLXS_MSGF(EMLXS_CONTEXT, &emlxs_fcsp_error_msg,
5803 ndlp->nlp_DID, privkey_len, dhgp_id);
5804
5805 if (big_init(&result1, CHARLEN2BIGNUMLEN(512)) != BIG_OK) {
5806 EMLXS_MSGF(EMLXS_CONTEXT, &emlxs_fcsp_error_msg,
5812 "emlxs_BIGNUM_get_dhval: big_init failed. result1 size=%d",
5807 "BIGNUM_get_dhval: big_init failed. result1 size=%d",
5813 CHARLEN2BIGNUMLEN(512));
5814
5815 err = BIG_NO_MEM;
5816 return (err);
5817 }
5818 if (big_init(&g, 1) != BIG_OK) {
5819 EMLXS_MSGF(EMLXS_CONTEXT, &emlxs_fcsp_error_msg,
5808 CHARLEN2BIGNUMLEN(512));
5809
5810 err = BIG_NO_MEM;
5811 return (err);
5812 }
5813 if (big_init(&g, 1) != BIG_OK) {
5814 EMLXS_MSGF(EMLXS_CONTEXT, &emlxs_fcsp_error_msg,
5820 "emlxs_BIGNUM_get_dhval: big_init failed. g size=1");
5815 "BIGNUM_get_dhval: big_init failed. g size=1");
5821
5822 err = BIG_NO_MEM;
5823 goto ret1;
5824 }
5825 /* get g */
5826 bytestring2bignum(&g, (unsigned char *)gen, sizeof (BIG_CHUNK_TYPE));
5827
5828 if (big_init(&e, CHARLEN2BIGNUMLEN(privkey_len)) != BIG_OK) {
5829 EMLXS_MSGF(EMLXS_CONTEXT, &emlxs_fcsp_error_msg,
5816
5817 err = BIG_NO_MEM;
5818 goto ret1;
5819 }
5820 /* get g */
5821 bytestring2bignum(&g, (unsigned char *)gen, sizeof (BIG_CHUNK_TYPE));
5822
5823 if (big_init(&e, CHARLEN2BIGNUMLEN(privkey_len)) != BIG_OK) {
5824 EMLXS_MSGF(EMLXS_CONTEXT, &emlxs_fcsp_error_msg,
5830 "emlxs_BIGNUM_get_dhval: big_init failed. e size=%d",
5825 "BIGNUM_get_dhval: big_init failed. e size=%d",
5831 CHARLEN2BIGNUMLEN(privkey_len));
5832
5833 err = BIG_NO_MEM;
5834 goto ret2;
5835 }
5836 /* get x */
5837 bytestring2bignum(&e, (unsigned char *)priv_key, privkey_len);
5838

--- 16 unchanged lines hidden (view full) ---

5855 case GROUP_2048:
5856 plen = 256;
5857 tmp = dhgp4_pVal;
5858 break;
5859 }
5860
5861 if (big_init(&n, CHARLEN2BIGNUMLEN(plen)) != BIG_OK) {
5862 EMLXS_MSGF(EMLXS_CONTEXT, &emlxs_fcsp_error_msg,
5826 CHARLEN2BIGNUMLEN(privkey_len));
5827
5828 err = BIG_NO_MEM;
5829 goto ret2;
5830 }
5831 /* get x */
5832 bytestring2bignum(&e, (unsigned char *)priv_key, privkey_len);
5833

--- 16 unchanged lines hidden (view full) ---

5850 case GROUP_2048:
5851 plen = 256;
5852 tmp = dhgp4_pVal;
5853 break;
5854 }
5855
5856 if (big_init(&n, CHARLEN2BIGNUMLEN(plen)) != BIG_OK) {
5857 EMLXS_MSGF(EMLXS_CONTEXT, &emlxs_fcsp_error_msg,
5863 "emlxs_BIGNUM_get_dhval: big_init failed. n size=%d",
5858 "BIGNUM_get_dhval: big_init failed. n size=%d",
5864 CHARLEN2BIGNUMLEN(plen));
5865
5866 err = BIG_NO_MEM;
5867 goto ret3;
5868 }
5869 /* get p */
5870 bytestring2bignum(&n, (unsigned char *)tmp, plen);
5871
5872 /* to cal: (g^x mod p) */
5873 if (big_modexp(&result1, &g, &e, &n, NULL) != BIG_OK) {
5874 EMLXS_MSGF(EMLXS_CONTEXT, &emlxs_fcsp_error_msg,
5859 CHARLEN2BIGNUMLEN(plen));
5860
5861 err = BIG_NO_MEM;
5862 goto ret3;
5863 }
5864 /* get p */
5865 bytestring2bignum(&n, (unsigned char *)tmp, plen);
5866
5867 /* to cal: (g^x mod p) */
5868 if (big_modexp(&result1, &g, &e, &n, NULL) != BIG_OK) {
5869 EMLXS_MSGF(EMLXS_CONTEXT, &emlxs_fcsp_error_msg,
5875 "emlxs_BIGNUM_get_dhval: big_modexp result1 error");
5870 "BIGNUM_get_dhval: big_modexp result1 error");
5876
5877 err = BIG_GENERAL_ERR;
5878 goto ret4;
5879 }
5880 /* convert big number pub_key to bytestring */
5881 if (ndlp->nlp_DID == FABRIC_DID) {
5882 bignum2bytestring(node_dhc->hrsp_pub_key, &result1,
5883 sizeof (BIG_CHUNK_TYPE) * (result1.len));

--- 57 unchanged lines hidden (view full) ---

5941 uint32_t *pubkeylen)
5942{
5943 BIGNUM a, e, n, result;
5944 uint32_t plen;
5945 unsigned char *tmp = NULL;
5946 BIG_ERR_CODE err = BIG_OK;
5947
5948 EMLXS_MSGF(EMLXS_CONTEXT, &emlxs_fcsp_detail_msg,
5871
5872 err = BIG_GENERAL_ERR;
5873 goto ret4;
5874 }
5875 /* convert big number pub_key to bytestring */
5876 if (ndlp->nlp_DID == FABRIC_DID) {
5877 bignum2bytestring(node_dhc->hrsp_pub_key, &result1,
5878 sizeof (BIG_CHUNK_TYPE) * (result1.len));

--- 57 unchanged lines hidden (view full) ---

5936 uint32_t *pubkeylen)
5937{
5938 BIGNUM a, e, n, result;
5939 uint32_t plen;
5940 unsigned char *tmp = NULL;
5941 BIG_ERR_CODE err = BIG_OK;
5942
5943 EMLXS_MSGF(EMLXS_CONTEXT, &emlxs_fcsp_detail_msg,
5949 "emlxs_BIGNUM_pubkey: dhvallen=0x%x dhgp_id=0x%x",
5944 "BIGNUM_pubkey: dhvallen=0x%x dhgp_id=0x%x",
5950 dhvallen, dhgp_id);
5951
5952 if (big_init(&a, CHARLEN2BIGNUMLEN(dhvallen)) != BIG_OK) {
5953 EMLXS_MSGF(EMLXS_CONTEXT, &emlxs_fcsp_error_msg,
5945 dhvallen, dhgp_id);
5946
5947 if (big_init(&a, CHARLEN2BIGNUMLEN(dhvallen)) != BIG_OK) {
5948 EMLXS_MSGF(EMLXS_CONTEXT, &emlxs_fcsp_error_msg,
5954 "emlxs_BIGNUM_pubkey: big_init failed. a size=%d",
5949 "BIGNUM_pubkey: big_init failed. a size=%d",
5955 CHARLEN2BIGNUMLEN(dhvallen));
5956
5957 err = BIG_NO_MEM;
5958 return (err);
5959 }
5960 /* get g^y mod p */
5961 bytestring2bignum(&a, (unsigned char *)dhval, dhvallen);
5962
5963 if (big_init(&e, CHARLEN2BIGNUMLEN(key_size)) != BIG_OK) {
5964 EMLXS_MSGF(EMLXS_CONTEXT, &emlxs_fcsp_error_msg,
5950 CHARLEN2BIGNUMLEN(dhvallen));
5951
5952 err = BIG_NO_MEM;
5953 return (err);
5954 }
5955 /* get g^y mod p */
5956 bytestring2bignum(&a, (unsigned char *)dhval, dhvallen);
5957
5958 if (big_init(&e, CHARLEN2BIGNUMLEN(key_size)) != BIG_OK) {
5959 EMLXS_MSGF(EMLXS_CONTEXT, &emlxs_fcsp_error_msg,
5965 "emlxs_BIGNUM_pubkey: big_init failed. e size=%d",
5960 "BIGNUM_pubkey: big_init failed. e size=%d",
5966 CHARLEN2BIGNUMLEN(key_size));
5967
5968 err = BIG_NO_MEM;
5969 goto ret1;
5970 }
5971 /* get x */
5972 bytestring2bignum(&e, (unsigned char *)key, key_size);
5973

--- 16 unchanged lines hidden (view full) ---

5990 case GROUP_2048:
5991 plen = 256;
5992 tmp = dhgp4_pVal;
5993 break;
5994 }
5995
5996 if (big_init(&n, CHARLEN2BIGNUMLEN(plen)) != BIG_OK) {
5997 EMLXS_MSGF(EMLXS_CONTEXT, &emlxs_fcsp_error_msg,
5961 CHARLEN2BIGNUMLEN(key_size));
5962
5963 err = BIG_NO_MEM;
5964 goto ret1;
5965 }
5966 /* get x */
5967 bytestring2bignum(&e, (unsigned char *)key, key_size);
5968

--- 16 unchanged lines hidden (view full) ---

5985 case GROUP_2048:
5986 plen = 256;
5987 tmp = dhgp4_pVal;
5988 break;
5989 }
5990
5991 if (big_init(&n, CHARLEN2BIGNUMLEN(plen)) != BIG_OK) {
5992 EMLXS_MSGF(EMLXS_CONTEXT, &emlxs_fcsp_error_msg,
5998 "emlxs_BIGNUM_pubkey: big_init failed. n size=%d",
5993 "BIGNUM_pubkey: big_init failed. n size=%d",
5999 CHARLEN2BIGNUMLEN(plen));
6000
6001 err = BIG_NO_MEM;
6002 goto ret2;
6003 }
6004 bytestring2bignum(&n, (unsigned char *)tmp, plen);
6005
6006 if (big_init(&result, CHARLEN2BIGNUMLEN(512)) != BIG_OK) {
6007 EMLXS_MSGF(EMLXS_CONTEXT, &emlxs_fcsp_error_msg,
5994 CHARLEN2BIGNUMLEN(plen));
5995
5996 err = BIG_NO_MEM;
5997 goto ret2;
5998 }
5999 bytestring2bignum(&n, (unsigned char *)tmp, plen);
6000
6001 if (big_init(&result, CHARLEN2BIGNUMLEN(512)) != BIG_OK) {
6002 EMLXS_MSGF(EMLXS_CONTEXT, &emlxs_fcsp_error_msg,
6008 "emlxs_BIGNUM_pubkey: big_init failed. result size=%d",
6003 "BIGNUM_pubkey: big_init failed. result size=%d",
6009 CHARLEN2BIGNUMLEN(512));
6010
6011 err = BIG_NO_MEM;
6012 goto ret3;
6013 }
6014 if (big_cmp_abs(&a, &n) > 0) {
6015 EMLXS_MSGF(EMLXS_CONTEXT, &emlxs_fcsp_error_msg,
6004 CHARLEN2BIGNUMLEN(512));
6005
6006 err = BIG_NO_MEM;
6007 goto ret3;
6008 }
6009 if (big_cmp_abs(&a, &n) > 0) {
6010 EMLXS_MSGF(EMLXS_CONTEXT, &emlxs_fcsp_error_msg,
6016 "emlxs_BIGNUM_pubkey: big_cmp_abs error");
6011 "BIGNUM_pubkey: big_cmp_abs error");
6017
6018 err = BIG_GENERAL_ERR;
6019 goto ret4;
6020 }
6021 if (big_modexp(&result, &a, &e, &n, NULL) != BIG_OK) {
6022 EMLXS_MSGF(EMLXS_CONTEXT, &emlxs_fcsp_error_msg,
6012
6013 err = BIG_GENERAL_ERR;
6014 goto ret4;
6015 }
6016 if (big_modexp(&result, &a, &e, &n, NULL) != BIG_OK) {
6017 EMLXS_MSGF(EMLXS_CONTEXT, &emlxs_fcsp_error_msg,
6023 "emlxs_BIGNUM_pubkey: big_modexp result error");
6018 "BIGNUM_pubkey: big_modexp result error");
6024
6025 err = BIG_NO_MEM;
6026 goto ret4;
6027 }
6028 bignum2bytestring(pubkey, &result,
6029 sizeof (BIG_CHUNK_TYPE) * (result.len));
6030 *pubkeylen = sizeof (BIG_CHUNK_TYPE) * (result.len);
6031

--- 42 unchanged lines hidden (view full) ---

6074 uint8_t md5_digest[16];
6075 uint8_t pubkey[512];
6076 uint32_t pubkey_len = 0;
6077 uint32_t key_size;
6078 BIG_ERR_CODE err = BIG_OK;
6079
6080 key_size = cval_len;
6081 EMLXS_MSGF(EMLXS_CONTEXT, &emlxs_fcsp_detail_msg,
6019
6020 err = BIG_NO_MEM;
6021 goto ret4;
6022 }
6023 bignum2bytestring(pubkey, &result,
6024 sizeof (BIG_CHUNK_TYPE) * (result.len));
6025 *pubkeylen = sizeof (BIG_CHUNK_TYPE) * (result.len);
6026

--- 42 unchanged lines hidden (view full) ---

6069 uint8_t md5_digest[16];
6070 uint8_t pubkey[512];
6071 uint32_t pubkey_len = 0;
6072 uint32_t key_size;
6073 BIG_ERR_CODE err = BIG_OK;
6074
6075 key_size = cval_len;
6076 EMLXS_MSGF(EMLXS_CONTEXT, &emlxs_fcsp_detail_msg,
6082 "emlxs_hash_Cai: 0x%x 0x%x 0x%x 0x%x 0x%x",
6077 "hash_Cai: 0x%x 0x%x 0x%x 0x%x 0x%x",
6083 ndlp->nlp_DID, hash_id, dhgp_id, tran_id, dhvallen);
6084
6085 if (hash_id == AUTH_MD5) {
6086 bzero(&mdctx, sizeof (MD5_CTX));
6087 MD5Init(&mdctx);
6088 MD5Update(&mdctx, (unsigned char *)cval, cval_len);
6089
6090 /* this pubkey obtained is actually the session key */
6091 /*
6092 * pubkey: ((g^y mod p)^x mod p)
6093 */
6094 err = emlxs_BIGNUM_pubkey(port, pubkey, dhval, dhvallen,
6095 key, key_size, dhgp_id, &pubkey_len);
6096
6097 if (err != BIG_OK) {
6098 EMLXS_MSGF(EMLXS_CONTEXT, &emlxs_fcsp_error_msg,
6078 ndlp->nlp_DID, hash_id, dhgp_id, tran_id, dhvallen);
6079
6080 if (hash_id == AUTH_MD5) {
6081 bzero(&mdctx, sizeof (MD5_CTX));
6082 MD5Init(&mdctx);
6083 MD5Update(&mdctx, (unsigned char *)cval, cval_len);
6084
6085 /* this pubkey obtained is actually the session key */
6086 /*
6087 * pubkey: ((g^y mod p)^x mod p)
6088 */
6089 err = emlxs_BIGNUM_pubkey(port, pubkey, dhval, dhvallen,
6090 key, key_size, dhgp_id, &pubkey_len);
6091
6092 if (err != BIG_OK) {
6093 EMLXS_MSGF(EMLXS_CONTEXT, &emlxs_fcsp_error_msg,
6099 "emlxs_hash_Cai: MD5 BIGNUM_pubkey error: 0x%x",
6094 "hash_Cai: MD5 BIGNUM_pubkey error: 0x%x",
6100 err);
6101
6102 err = BIG_GENERAL_ERR;
6103 return (err);
6104 }
6105 if (pubkey_len == 0) {
6106 EMLXS_MSGF(EMLXS_CONTEXT, &emlxs_fcsp_error_msg,
6095 err);
6096
6097 err = BIG_GENERAL_ERR;
6098 return (err);
6099 }
6100 if (pubkey_len == 0) {
6101 EMLXS_MSGF(EMLXS_CONTEXT, &emlxs_fcsp_error_msg,
6107 "emlxs_hash_Cai: MD5 BIGNUM_pubkey error: len=0");
6102 "hash_Cai: MD5 BIGNUM_pubkey error: len=0");
6108
6109 err = BIG_GENERAL_ERR;
6110 return (err);
6111 }
6112 if (ndlp->nlp_DID == FABRIC_DID) {
6113 bcopy((void *)pubkey,
6114 (void *)node_dhc->hrsp_ses_key, pubkey_len);
6115 node_dhc->hrsp_seskey_len = pubkey_len;

--- 21 unchanged lines hidden (view full) ---

6137
6138 SHA1Update(&sha1ctx, (void *)cval, cval_len);
6139
6140 err = emlxs_BIGNUM_pubkey(port, pubkey, dhval, dhvallen,
6141 key, key_size, dhgp_id, &pubkey_len);
6142
6143 if (err != BIG_OK) {
6144 EMLXS_MSGF(EMLXS_CONTEXT, &emlxs_fcsp_error_msg,
6103
6104 err = BIG_GENERAL_ERR;
6105 return (err);
6106 }
6107 if (ndlp->nlp_DID == FABRIC_DID) {
6108 bcopy((void *)pubkey,
6109 (void *)node_dhc->hrsp_ses_key, pubkey_len);
6110 node_dhc->hrsp_seskey_len = pubkey_len;

--- 21 unchanged lines hidden (view full) ---

6132
6133 SHA1Update(&sha1ctx, (void *)cval, cval_len);
6134
6135 err = emlxs_BIGNUM_pubkey(port, pubkey, dhval, dhvallen,
6136 key, key_size, dhgp_id, &pubkey_len);
6137
6138 if (err != BIG_OK) {
6139 EMLXS_MSGF(EMLXS_CONTEXT, &emlxs_fcsp_error_msg,
6145 "emlxs_hash_Cai: SHA1 BIGNUM_pubkey error: 0x%x",
6140 "hash_Cai: SHA1 BIGNUM_pubkey error: 0x%x",
6146 err);
6147
6148 err = BIG_GENERAL_ERR;
6149 return (err);
6150 }
6151 if (pubkey_len == 0) {
6152 EMLXS_MSGF(EMLXS_CONTEXT, &emlxs_fcsp_error_msg,
6141 err);
6142
6143 err = BIG_GENERAL_ERR;
6144 return (err);
6145 }
6146 if (pubkey_len == 0) {
6147 EMLXS_MSGF(EMLXS_CONTEXT, &emlxs_fcsp_error_msg,
6153 "emlxs_hash_Cai: SA1 BUM_pubkey error: key_len=0");
6148 "hash_Cai: SA1 BUM_pubkey error: key_len=0");
6154
6155 err = BIG_GENERAL_ERR;
6156 return (err);
6157 }
6158 if (ndlp->nlp_DID == FABRIC_DID) {
6159 bcopy((void *)pubkey,
6160 (void *)node_dhc->hrsp_ses_key,
6161 pubkey_len);

--- 80 unchanged lines hidden (view full) ---

6242 dhgp_id = node_dhc->dhgp_id;
6243 hash_id = node_dhc->hash_id;
6244 } else {
6245 dhgp_id = node_dhc->nlp_auth_dhgpid;
6246 hash_id = node_dhc->nlp_auth_hashid;
6247 }
6248
6249 EMLXS_MSGF(EMLXS_CONTEXT, &emlxs_fcsp_detail_msg,
6149
6150 err = BIG_GENERAL_ERR;
6151 return (err);
6152 }
6153 if (ndlp->nlp_DID == FABRIC_DID) {
6154 bcopy((void *)pubkey,
6155 (void *)node_dhc->hrsp_ses_key,
6156 pubkey_len);

--- 80 unchanged lines hidden (view full) ---

6237 dhgp_id = node_dhc->dhgp_id;
6238 hash_id = node_dhc->hash_id;
6239 } else {
6240 dhgp_id = node_dhc->nlp_auth_dhgpid;
6241 hash_id = node_dhc->nlp_auth_hashid;
6242 }
6243
6244 EMLXS_MSGF(EMLXS_CONTEXT, &emlxs_fcsp_detail_msg,
6250 "emlxs_hash_verification: 0x%x 0x%x hash_id=0x%x dhgp_id=0x%x",
6245 "hash_verification: 0x%x 0x%x hash_id=0x%x dhgp_id=0x%x",
6251 ndlp->nlp_DID, mytran_id, hash_id, dhgp_id);
6252
6253 if (dhval_len == 0) {
6254 /* NULL DHCHAP group */
6255 if (hash_id == AUTH_MD5) {
6256 bzero(&mdctx, sizeof (MD5_CTX));
6257 hash_size = MD5_LEN;
6258 MD5Init(&mdctx);

--- 21 unchanged lines hidden (view full) ---

6280 }
6281
6282 MD5Final((uint8_t *)md5_digest, &mdctx);
6283
6284 hash_val = (uint32_t *)kmem_alloc(hash_size,
6285 KM_NOSLEEP);
6286 if (hash_val == NULL) {
6287 EMLXS_MSGF(EMLXS_CONTEXT, &emlxs_fcsp_error_msg,
6246 ndlp->nlp_DID, mytran_id, hash_id, dhgp_id);
6247
6248 if (dhval_len == 0) {
6249 /* NULL DHCHAP group */
6250 if (hash_id == AUTH_MD5) {
6251 bzero(&mdctx, sizeof (MD5_CTX));
6252 hash_size = MD5_LEN;
6253 MD5Init(&mdctx);

--- 21 unchanged lines hidden (view full) ---

6275 }
6276
6277 MD5Final((uint8_t *)md5_digest, &mdctx);
6278
6279 hash_val = (uint32_t *)kmem_alloc(hash_size,
6280 KM_NOSLEEP);
6281 if (hash_val == NULL) {
6282 EMLXS_MSGF(EMLXS_CONTEXT, &emlxs_fcsp_error_msg,
6288 "emlxs_hash_verification: alloc failed");
6283 "hash_verification: alloc failed");
6289
6290 return (NULL);
6291 } else {
6292 bcopy((void *)md5_digest,
6293 (void *)hash_val, MD5_LEN);
6294 }
6295 }
6296 if (hash_id == AUTH_SHA1) {

--- 20 unchanged lines hidden (view full) ---

6317 SHA1_LEN);
6318 }
6319
6320 SHA1Final((void *)sha1_digest, &sha1ctx);
6321 hash_val = (uint32_t *)kmem_zalloc(hash_size,
6322 KM_NOSLEEP);
6323 if (hash_val == NULL) {
6324 EMLXS_MSGF(EMLXS_CONTEXT, &emlxs_fcsp_error_msg,
6284
6285 return (NULL);
6286 } else {
6287 bcopy((void *)md5_digest,
6288 (void *)hash_val, MD5_LEN);
6289 }
6290 }
6291 if (hash_id == AUTH_SHA1) {

--- 20 unchanged lines hidden (view full) ---

6312 SHA1_LEN);
6313 }
6314
6315 SHA1Final((void *)sha1_digest, &sha1ctx);
6316 hash_val = (uint32_t *)kmem_zalloc(hash_size,
6317 KM_NOSLEEP);
6318 if (hash_val == NULL) {
6319 EMLXS_MSGF(EMLXS_CONTEXT, &emlxs_fcsp_error_msg,
6325 "emlxs_hash_verification: alloc failed");
6320 "hash_verification: alloc failed");
6326
6327 return (NULL);
6328 } else {
6329 bcopy((void *)sha1_digest,
6330 (void *)hash_val, SHA1_LEN);
6331 }
6332 }
6333 EMLXS_MSGF(EMLXS_CONTEXT, &emlxs_fcsp_detail_msg,
6321
6322 return (NULL);
6323 } else {
6324 bcopy((void *)sha1_digest,
6325 (void *)hash_val, SHA1_LEN);
6326 }
6327 }
6328 EMLXS_MSGF(EMLXS_CONTEXT, &emlxs_fcsp_detail_msg,
6334 "emlxs_hash_verification: hash_val=0x%x",
6329 "hash_verification: hash_val=0x%x",
6335 *(uint32_t *)hash_val);
6336
6337 return ((uint32_t *)hash_val);
6338 } else {
6339
6340 /* DHCHAP group 1,2,3,4 */
6341 /*
6342 * host received (g^x mod p) as dhval host has its own

--- 31 unchanged lines hidden (view full) ---

6374 } else {
6375 bcopy((void *)node_dhc->nlp_auth_misc.hrsp_cval,
6376 (void *)cval,
6377 node_dhc->nlp_auth_misc.hrsp_cval_len);
6378 cval_len = node_dhc->nlp_auth_misc.hrsp_cval_len;
6379 }
6380
6381 EMLXS_MSGF(EMLXS_CONTEXT, &emlxs_fcsp_detail_msg,
6330 *(uint32_t *)hash_val);
6331
6332 return ((uint32_t *)hash_val);
6333 } else {
6334
6335 /* DHCHAP group 1,2,3,4 */
6336 /*
6337 * host received (g^x mod p) as dhval host has its own

--- 31 unchanged lines hidden (view full) ---

6369 } else {
6370 bcopy((void *)node_dhc->nlp_auth_misc.hrsp_cval,
6371 (void *)cval,
6372 node_dhc->nlp_auth_misc.hrsp_cval_len);
6373 cval_len = node_dhc->nlp_auth_misc.hrsp_cval_len;
6374 }
6375
6376 EMLXS_MSGF(EMLXS_CONTEXT, &emlxs_fcsp_detail_msg,
6382 "emlxs_hash_verification: N-Null gp. 0x%x 0x%x",
6377 "hash_verification: N-Null gp. 0x%x 0x%x",
6383 ndlp->nlp_DID, cval_len);
6384
6385 err = emlxs_hash_Cai(port, port_dhc, ndlp, (void *)Cai,
6386 hash_id, dhgp_id,
6387 tran_id, cval, cval_len,
6388 key, dhval, dhval_len);
6389
6390 if (err != BIG_OK) {
6391 EMLXS_MSGF(EMLXS_CONTEXT, &emlxs_fcsp_error_msg,
6378 ndlp->nlp_DID, cval_len);
6379
6380 err = emlxs_hash_Cai(port, port_dhc, ndlp, (void *)Cai,
6381 hash_id, dhgp_id,
6382 tran_id, cval, cval_len,
6383 key, dhval, dhval_len);
6384
6385 if (err != BIG_OK) {
6386 EMLXS_MSGF(EMLXS_CONTEXT, &emlxs_fcsp_error_msg,
6392 "emlxs_hash_verification: Cai error. ret=0x%x",
6387 "hash_verification: Cai error. ret=0x%x",
6393 err);
6394
6395 return (NULL);
6396 }
6397 if (hash_id == AUTH_MD5) {
6398 bzero(&mdctx, sizeof (MD5_CTX));
6399 hash_size = MD5_LEN;
6400

--- 12 unchanged lines hidden (view full) ---

6413
6414 MD5Update(&mdctx, (unsigned char *)Cai, MD5_LEN);
6415 MD5Final((uint8_t *)md5_digest, &mdctx);
6416
6417 hash_val = (uint32_t *)kmem_zalloc(hash_size,
6418 KM_NOSLEEP);
6419 if (hash_val == NULL) {
6420 EMLXS_MSGF(EMLXS_CONTEXT, &emlxs_fcsp_error_msg,
6388 err);
6389
6390 return (NULL);
6391 }
6392 if (hash_id == AUTH_MD5) {
6393 bzero(&mdctx, sizeof (MD5_CTX));
6394 hash_size = MD5_LEN;
6395

--- 12 unchanged lines hidden (view full) ---

6408
6409 MD5Update(&mdctx, (unsigned char *)Cai, MD5_LEN);
6410 MD5Final((uint8_t *)md5_digest, &mdctx);
6411
6412 hash_val = (uint32_t *)kmem_zalloc(hash_size,
6413 KM_NOSLEEP);
6414 if (hash_val == NULL) {
6415 EMLXS_MSGF(EMLXS_CONTEXT, &emlxs_fcsp_error_msg,
6421 "emlxs_hash_vf: alloc failed(Non-NULL dh)");
6416 "hash_vf: alloc failed(Non-NULL dh)");
6422
6423 return (NULL);
6424 } else {
6425 bcopy((void *)&md5_digest,
6426 (void *)hash_val, MD5_LEN);
6427 }
6428 }
6429 if (hash_id == AUTH_SHA1) {

--- 13 unchanged lines hidden (view full) ---

6443
6444 SHA1Update(&sha1ctx, (void *)Cai, SHA1_LEN);
6445 SHA1Final((void *)sha1_digest, &sha1ctx);
6446
6447 hash_val = (uint32_t *)kmem_zalloc(hash_size,
6448 KM_NOSLEEP);
6449 if (hash_val == NULL) {
6450 EMLXS_MSGF(EMLXS_CONTEXT, &emlxs_fcsp_error_msg,
6417
6418 return (NULL);
6419 } else {
6420 bcopy((void *)&md5_digest,
6421 (void *)hash_val, MD5_LEN);
6422 }
6423 }
6424 if (hash_id == AUTH_SHA1) {

--- 13 unchanged lines hidden (view full) ---

6438
6439 SHA1Update(&sha1ctx, (void *)Cai, SHA1_LEN);
6440 SHA1Final((void *)sha1_digest, &sha1ctx);
6441
6442 hash_val = (uint32_t *)kmem_zalloc(hash_size,
6443 KM_NOSLEEP);
6444 if (hash_val == NULL) {
6445 EMLXS_MSGF(EMLXS_CONTEXT, &emlxs_fcsp_error_msg,
6451 "emlxs_hash_vf: val alloc failed (Non-NULL dh)");
6446 "hash_vf: val alloc failed (Non-NULL dh)");
6452
6453 return (NULL);
6454 } else {
6455 bcopy((void *)&sha1_digest,
6456 (void *)hash_val, SHA1_LEN);
6457 }
6458 }
6459 EMLXS_MSGF(EMLXS_CONTEXT, &emlxs_fcsp_detail_msg,
6447
6448 return (NULL);
6449 } else {
6450 bcopy((void *)&sha1_digest,
6451 (void *)hash_val, SHA1_LEN);
6452 }
6453 }
6454 EMLXS_MSGF(EMLXS_CONTEXT, &emlxs_fcsp_detail_msg,
6460 "emlxs_hash_verification: hash_val=0x%x",
6455 "hash_verification: hash_val=0x%x",
6461 *(uint32_t *)hash_val);
6462
6463 return ((uint32_t *)hash_val);
6464 }
6465
6466} /* emlxs_hash_verification */
6467
6468

--- 62 unchanged lines hidden (view full) ---

6531 hash_id = node_dhc->nlp_auth_hashid;
6532 }
6533 }
6534
6535 tran_id = (AUTH_TRAN_ID_MASK & tran_id);
6536 mytran_id = (uint8_t)(LE_SWAP32(tran_id));
6537
6538 EMLXS_MSGF(EMLXS_CONTEXT, &emlxs_fcsp_detail_msg,
6456 *(uint32_t *)hash_val);
6457
6458 return ((uint32_t *)hash_val);
6459 }
6460
6461} /* emlxs_hash_verification */
6462
6463

--- 62 unchanged lines hidden (view full) ---

6526 hash_id = node_dhc->nlp_auth_hashid;
6527 }
6528 }
6529
6530 tran_id = (AUTH_TRAN_ID_MASK & tran_id);
6531 mytran_id = (uint8_t)(LE_SWAP32(tran_id));
6532
6533 EMLXS_MSGF(EMLXS_CONTEXT, &emlxs_fcsp_detail_msg,
6539 "emlxs_hash_get_R2:0x%x 0x%x dhgp_id=0x%x mytran_id=0x%x",
6534 "hash_get_R2:0x%x 0x%x dhgp_id=0x%x mytran_id=0x%x",
6540 ndlp->nlp_DID, hash_id, dhgp_id, mytran_id);
6541
6542 if (ndlp->nlp_DID == FABRIC_DID) {
6543 mykey = (char *)node_dhc->auth_key.local_password;
6544
6545 } else {
6546 /* in case of end-to-end mykey should be remote_password */
6547 mykey = (char *)node_dhc->auth_key.remote_password;

--- 90 unchanged lines hidden (view full) ---

6638 * R2 = H (Ti || Km || Cai)
6639 */
6640 err = emlxs_hash_Cai(port, port_dhc, ndlp, (void *)Cai,
6641 hash_id, dhgp_id, tran_id, bi_cval, cval_len,
6642 key, dhval, dhval_len);
6643
6644 if (err != BIG_OK) {
6645 EMLXS_MSGF(EMLXS_CONTEXT, &emlxs_fcsp_error_msg,
6535 ndlp->nlp_DID, hash_id, dhgp_id, mytran_id);
6536
6537 if (ndlp->nlp_DID == FABRIC_DID) {
6538 mykey = (char *)node_dhc->auth_key.local_password;
6539
6540 } else {
6541 /* in case of end-to-end mykey should be remote_password */
6542 mykey = (char *)node_dhc->auth_key.remote_password;

--- 90 unchanged lines hidden (view full) ---

6633 * R2 = H (Ti || Km || Cai)
6634 */
6635 err = emlxs_hash_Cai(port, port_dhc, ndlp, (void *)Cai,
6636 hash_id, dhgp_id, tran_id, bi_cval, cval_len,
6637 key, dhval, dhval_len);
6638
6639 if (err != BIG_OK) {
6640 EMLXS_MSGF(EMLXS_CONTEXT, &emlxs_fcsp_error_msg,
6646 "emlxs_hash_get_R2: emlxs_hash_Cai error. ret=0x%x",
6641 "hash_get_R2: hash_Cai error. ret=0x%x",
6647 err);
6648
6649 return (NULL);
6650 }
6651 if (hash_id == AUTH_MD5) {
6652 bzero(&mdctx, sizeof (MD5_CTX));
6653 hash_size = MD5_LEN;
6654

--- 14 unchanged lines hidden (view full) ---

6669
6670 MD5Update(&mdctx, (unsigned char *)Cai, MD5_LEN);
6671 MD5Final((uint8_t *)md5_digest, &mdctx);
6672
6673 hash_val = (uint32_t *)kmem_alloc(hash_size,
6674 KM_NOSLEEP);
6675 if (hash_val == NULL) {
6676 EMLXS_MSGF(EMLXS_CONTEXT, &emlxs_fcsp_error_msg,
6642 err);
6643
6644 return (NULL);
6645 }
6646 if (hash_id == AUTH_MD5) {
6647 bzero(&mdctx, sizeof (MD5_CTX));
6648 hash_size = MD5_LEN;
6649

--- 14 unchanged lines hidden (view full) ---

6664
6665 MD5Update(&mdctx, (unsigned char *)Cai, MD5_LEN);
6666 MD5Final((uint8_t *)md5_digest, &mdctx);
6667
6668 hash_val = (uint32_t *)kmem_alloc(hash_size,
6669 KM_NOSLEEP);
6670 if (hash_val == NULL) {
6671 EMLXS_MSGF(EMLXS_CONTEXT, &emlxs_fcsp_error_msg,
6677 "emlxs_hash_get_R2: hash_val MD5 alloc failed.");
6672 "hash_get_R2: hash_val MD5 alloc failed.");
6678
6679 return (NULL);
6680 } else {
6681 bcopy((void *)md5_digest,
6682 (void *)hash_val, MD5_LEN);
6683 }
6684 }
6685 if (hash_id == AUTH_SHA1) {

--- 13 unchanged lines hidden (view full) ---

6699
6700 SHA1Update(&sha1ctx, (void *)Cai, SHA1_LEN);
6701 SHA1Final((void *)sha1_digest, &sha1ctx);
6702
6703 hash_val = (uint32_t *)kmem_alloc(hash_size,
6704 KM_NOSLEEP);
6705 if (hash_val == NULL) {
6706 EMLXS_MSGF(EMLXS_CONTEXT, &emlxs_fcsp_error_msg,
6673
6674 return (NULL);
6675 } else {
6676 bcopy((void *)md5_digest,
6677 (void *)hash_val, MD5_LEN);
6678 }
6679 }
6680 if (hash_id == AUTH_SHA1) {

--- 13 unchanged lines hidden (view full) ---

6694
6695 SHA1Update(&sha1ctx, (void *)Cai, SHA1_LEN);
6696 SHA1Final((void *)sha1_digest, &sha1ctx);
6697
6698 hash_val = (uint32_t *)kmem_alloc(hash_size,
6699 KM_NOSLEEP);
6700 if (hash_val == NULL) {
6701 EMLXS_MSGF(EMLXS_CONTEXT, &emlxs_fcsp_error_msg,
6707 "emlxs_hash_get_R2: hash_val SHA1 alloc failed.");
6702 "hash_get_R2: hash_val SHA1 alloc failed.");
6708
6709 return (NULL);
6710 } else {
6711 bcopy((void *)sha1_digest,
6712 (void *)hash_val, SHA1_LEN);
6713 }
6714 }
6715 }
6716
6717 return ((uint32_t *)hash_val);
6718
6719} /* emlxs_hash_get_R2 */
6720
6721
6703
6704 return (NULL);
6705 } else {
6706 bcopy((void *)sha1_digest,
6707 (void *)hash_val, SHA1_LEN);
6708 }
6709 }
6710 }
6711
6712 return ((uint32_t *)hash_val);
6713
6714} /* emlxs_hash_get_R2 */
6715
6716
6722
6723/*
6724 */
6725static void
6726emlxs_log_auth_event(
6727 emlxs_port_t *port,
6728 NODELIST *ndlp,
6729 char *subclass,
6730 char *info)
6731{
6732 emlxs_hba_t *hba = HBA;
6733 emlxs_node_dhc_t *node_dhc = &ndlp->node_dhc;
6734 nvlist_t *attr_list = NULL;
6735 dev_info_t *dip = hba->dip;
6736 emlxs_auth_cfg_t *auth_cfg;
6737 char *tmp = "No_more_logging_information_available";
6717static void
6718emlxs_log_auth_event(
6719 emlxs_port_t *port,
6720 NODELIST *ndlp,
6721 char *subclass,
6722 char *info)
6723{
6724 emlxs_hba_t *hba = HBA;
6725 emlxs_node_dhc_t *node_dhc = &ndlp->node_dhc;
6726 nvlist_t *attr_list = NULL;
6727 dev_info_t *dip = hba->dip;
6728 emlxs_auth_cfg_t *auth_cfg;
6729 char *tmp = "No_more_logging_information_available";
6738
6739 uint8_t lwwn[8];
6740 uint8_t rwwn[8];
6730 uint8_t lwwn[8];
6731 uint8_t rwwn[8];
6741 char *lwwn_tmp = NULL;
6742 char *rwwn_tmp = NULL;
6743 char *mytmp_lwwn, *mytmp_rwwn;
6744 int i;
6732 char *lwwn_str = NULL;
6733 char *rwwn_str = NULL;
6734 char ext_subclass[128];
6735 char ext_class[32];
6745
6746 auth_cfg = &(node_dhc->auth_cfg);
6747
6748 if (info == NULL) {
6749 info = tmp;
6750 }
6751 bcopy((void *) &auth_cfg->local_entity, (void *)lwwn, 8);
6736
6737 auth_cfg = &(node_dhc->auth_cfg);
6738
6739 if (info == NULL) {
6740 info = tmp;
6741 }
6742 bcopy((void *) &auth_cfg->local_entity, (void *)lwwn, 8);
6752 lwwn_tmp = (char *)kmem_zalloc(32, KM_NOSLEEP);
6753 if (lwwn_tmp == NULL) {
6743 lwwn_str = (char *)kmem_zalloc(32, KM_NOSLEEP);
6744 if (lwwn_str == NULL) {
6754 return;
6755 }
6745 return;
6746 }
6756 mytmp_lwwn = lwwn_tmp;
6747 (void) snprintf(lwwn_str, 32, "%02X%02X%02X%02X%02X%02X%02X%02X",
6748 lwwn[0], lwwn[1], lwwn[2], lwwn[3], lwwn[4], lwwn[5], lwwn[6],
6749 lwwn[7]);
6757
6750
6758 for (i = 0; i < 8; i++) {
6759 lwwn_tmp = (char *)sprintf((char *)lwwn_tmp, "%02X", lwwn[i]);
6760 lwwn_tmp += 2;
6761 }
6762 mytmp_lwwn[16] = '\0';
6763
6764 bcopy((void *)&auth_cfg->remote_entity, (void *)rwwn, 8);
6751 bcopy((void *)&auth_cfg->remote_entity, (void *)rwwn, 8);
6765 rwwn_tmp = (char *)kmem_zalloc(32, KM_NOSLEEP);
6766
6767 mytmp_rwwn = rwwn_tmp;
6768
6769 if (rwwn_tmp == NULL) {
6770 kmem_free(mytmp_lwwn, 32);
6752 rwwn_str = (char *)kmem_zalloc(32, KM_NOSLEEP);
6753 if (rwwn_str == NULL) {
6754 kmem_free(lwwn_str, 32);
6771 return;
6772 }
6755 return;
6756 }
6773 for (i = 0; i < 8; i++) {
6774 rwwn_tmp = (char *)sprintf((char *)rwwn_tmp, "%02X", rwwn[i]);
6775 rwwn_tmp += 2;
6776 }
6777 mytmp_rwwn[16] = '\0';
6778
6757
6758 (void) snprintf(rwwn_str, 32, "%02X%02X%02X%02X%02X%02X%02X%02X",
6759 rwwn[0], rwwn[1], rwwn[2], rwwn[3], rwwn[4], rwwn[5], rwwn[6],
6760 rwwn[7]);
6761
6762 (void) snprintf(ext_subclass, sizeof (ext_subclass),
6763 "ESC_%s_%s", DRIVER_NAME, subclass);
6764 (void) snprintf(ext_class, sizeof (ext_class),
6765 "EC_%s", DRIVER_NAME);
6766
6779 if (nvlist_alloc(&attr_list, NV_UNIQUE_NAME_TYPE, KM_NOSLEEP)
6780 == DDI_SUCCESS) {
6781 if ((nvlist_add_uint32(attr_list, "instance",
6782 ddi_get_instance(dip)) == DDI_SUCCESS) &&
6783 (nvlist_add_string(attr_list, "lwwn",
6767 if (nvlist_alloc(&attr_list, NV_UNIQUE_NAME_TYPE, KM_NOSLEEP)
6768 == DDI_SUCCESS) {
6769 if ((nvlist_add_uint32(attr_list, "instance",
6770 ddi_get_instance(dip)) == DDI_SUCCESS) &&
6771 (nvlist_add_string(attr_list, "lwwn",
6784 (char *)mytmp_lwwn) == DDI_SUCCESS) &&
6772 lwwn_str) == DDI_SUCCESS) &&
6785 (nvlist_add_string(attr_list, "rwwn",
6773 (nvlist_add_string(attr_list, "rwwn",
6786 (char *)mytmp_rwwn) == DDI_SUCCESS) &&
6774 rwwn_str) == DDI_SUCCESS) &&
6787 (nvlist_add_string(attr_list, "Info",
6788 info) == DDI_SUCCESS) &&
6789 (nvlist_add_string(attr_list, "Class",
6775 (nvlist_add_string(attr_list, "Info",
6776 info) == DDI_SUCCESS) &&
6777 (nvlist_add_string(attr_list, "Class",
6790 "EC_emlx") == DDI_SUCCESS) &&
6778 ext_class) == DDI_SUCCESS) &&
6791 (nvlist_add_string(attr_list, "SubClass",
6779 (nvlist_add_string(attr_list, "SubClass",
6792 subclass) == DDI_SUCCESS)) {
6780 ext_subclass) == DDI_SUCCESS)) {
6793
6794 (void) ddi_log_sysevent(dip,
6781
6782 (void) ddi_log_sysevent(dip,
6795 DDI_VENDOR_EMLX,
6796 EC_EMLXS,
6797 subclass,
6783 emlxs_strtoupper(DRIVER_NAME),
6784 ext_class,
6785 ext_subclass,
6798 attr_list,
6799 NULL,
6800 DDI_NOSLEEP);
6801 }
6802 nvlist_free(attr_list);
6803 attr_list = NULL;
6804 }
6786 attr_list,
6787 NULL,
6788 DDI_NOSLEEP);
6789 }
6790 nvlist_free(attr_list);
6791 attr_list = NULL;
6792 }
6805 kmem_free(mytmp_lwwn, 32);
6806 kmem_free(mytmp_rwwn, 32);
6793 kmem_free(lwwn_str, 32);
6794 kmem_free(rwwn_str, 32);
6807
6808 return;
6809
6810} /* emlxs_log_auth_event() */
6811
6812
6813/* **************************** AUTH DHC INTERFACE ************************* */
6814

--- 479 unchanged lines hidden (view full) ---

7294 return;
7295
7296} /* emlxs_dhc_auth_complete */
7297
7298
7299extern void
7300emlxs_dhc_attach(emlxs_hba_t *hba)
7301{
6795
6796 return;
6797
6798} /* emlxs_log_auth_event() */
6799
6800
6801/* **************************** AUTH DHC INTERFACE ************************* */
6802

--- 479 unchanged lines hidden (view full) ---

7282 return;
7283
7284} /* emlxs_dhc_auth_complete */
7285
7286
7287extern void
7288emlxs_dhc_attach(emlxs_hba_t *hba)
7289{
7302 char buf[32];
7290 mutex_init(&hba->auth_lock, NULL, MUTEX_DRIVER, NULL);
7303
7291
7304 (void) sprintf(buf, "%s_auth_lock mutex", DRIVER_NAME);
7305 mutex_init(&hba->auth_lock, buf, MUTEX_DRIVER, NULL);
7292 mutex_init(&hba->dhc_lock, NULL, MUTEX_DRIVER, NULL);
7306
7293
7307 (void) sprintf(buf, "%s_dhc_lock mutex", DRIVER_NAME);
7308 mutex_init(&hba->dhc_lock, buf, MUTEX_DRIVER, NULL);
7309
7310 emlxs_auth_cfg_init(hba);
7311
7312 emlxs_auth_key_init(hba);
7313
7314 hba->rdn_flag = 1;
7315
7316 return;
7317

--- 541 unchanged lines hidden (view full) ---

7859
7860 char s_lwwpn[32];
7861 char s_rwwpn[32];
7862
7863 /* Create and add new entry */
7864 EMLXS_MSGF(EMLXS_CONTEXT,
7865 &emlxs_fcsp_detail_msg,
7866 "%s:%s:%x:%x:%x:%x%x%x%x:%x%x%x%x:%x%x%x%x%x%x%x%x:%x",
7294 emlxs_auth_cfg_init(hba);
7295
7296 emlxs_auth_key_init(hba);
7297
7298 hba->rdn_flag = 1;
7299
7300 return;
7301

--- 541 unchanged lines hidden (view full) ---

7843
7844 char s_lwwpn[32];
7845 char s_rwwpn[32];
7846
7847 /* Create and add new entry */
7848 EMLXS_MSGF(EMLXS_CONTEXT,
7849 &emlxs_fcsp_detail_msg,
7850 "%s:%s:%x:%x:%x:%x%x%x%x:%x%x%x%x:%x%x%x%x%x%x%x%x:%x",
7867 emlxs_wwn_xlate(s_lwwpn, (uint8_t *)&auth_cfg->local_entity),
7868 emlxs_wwn_xlate(s_rwwpn, (uint8_t *)&auth_cfg->remote_entity),
7851 emlxs_wwn_xlate(s_lwwpn, sizeof (s_lwwpn),
7852 (uint8_t *)&auth_cfg->local_entity),
7853 emlxs_wwn_xlate(s_rwwpn, sizeof (s_rwwpn),
7854 (uint8_t *)&auth_cfg->remote_entity),
7869 auth_cfg->authentication_timeout,
7870 auth_cfg->authentication_mode,
7871 auth_cfg->bidirectional,
7872 auth_cfg->authentication_type_priority[0],
7873 auth_cfg->authentication_type_priority[1],
7874 auth_cfg->authentication_type_priority[2],
7875 auth_cfg->authentication_type_priority[3],
7876 auth_cfg->hash_priority[0],

--- 133 unchanged lines hidden (view full) ---

8010 emlxs_auth_cfg_t *auth_cfg2;
8011 uint32_t cnt;
8012 uint32_t rval;
8013 char buffer[64];
8014 char *prop_str;
8015 uint32_t i;
8016
8017 /* Check for the per adapter setting */
7855 auth_cfg->authentication_timeout,
7856 auth_cfg->authentication_mode,
7857 auth_cfg->bidirectional,
7858 auth_cfg->authentication_type_priority[0],
7859 auth_cfg->authentication_type_priority[1],
7860 auth_cfg->authentication_type_priority[2],
7861 auth_cfg->authentication_type_priority[3],
7862 auth_cfg->hash_priority[0],

--- 133 unchanged lines hidden (view full) ---

7996 emlxs_auth_cfg_t *auth_cfg2;
7997 uint32_t cnt;
7998 uint32_t rval;
7999 char buffer[64];
8000 char *prop_str;
8001 uint32_t i;
8002
8003 /* Check for the per adapter setting */
8018 (void) sprintf(buffer, "%s%d-auth-cfgs", DRIVER_NAME, hba->ddiinst);
8004 (void) snprintf(buffer, sizeof (buffer), "%s%d-auth-cfgs", DRIVER_NAME,
8005 hba->ddiinst);
8019 cnt = 0;
8020 arrayp = NULL;
8021 rval = ddi_prop_lookup_string_array(DDI_DEV_T_ANY, hba->dip,
8022 (DDI_PROP_DONTPASS),
8023 buffer, &arrayp, &cnt);
8024
8025 if ((rval != DDI_PROP_SUCCESS) || !cnt || !arrayp) {
8026 /* Check for the global setting */

--- 499 unchanged lines hidden (view full) ---

8526{
8527 emlxs_port_t *port = &PPORT;
8528 char s_lwwpn[32];
8529 char s_rwwpn[32];
8530
8531 EMLXS_MSGF(EMLXS_CONTEXT,
8532 &emlxs_fcsp_detail_msg,
8533 "auth-key> %s:%s:%x:*%d chars*:%x:*%d chars*",
8006 cnt = 0;
8007 arrayp = NULL;
8008 rval = ddi_prop_lookup_string_array(DDI_DEV_T_ANY, hba->dip,
8009 (DDI_PROP_DONTPASS),
8010 buffer, &arrayp, &cnt);
8011
8012 if ((rval != DDI_PROP_SUCCESS) || !cnt || !arrayp) {
8013 /* Check for the global setting */

--- 499 unchanged lines hidden (view full) ---

8513{
8514 emlxs_port_t *port = &PPORT;
8515 char s_lwwpn[32];
8516 char s_rwwpn[32];
8517
8518 EMLXS_MSGF(EMLXS_CONTEXT,
8519 &emlxs_fcsp_detail_msg,
8520 "auth-key> %s:%s:%x:*%d chars*:%x:*%d chars*",
8534 emlxs_wwn_xlate(s_lwwpn, (uint8_t *)&auth_key->local_entity),
8535 emlxs_wwn_xlate(s_rwwpn, (uint8_t *)&auth_key->remote_entity),
8521 emlxs_wwn_xlate(s_lwwpn, sizeof (s_lwwpn),
8522 (uint8_t *)&auth_key->local_entity),
8523 emlxs_wwn_xlate(s_rwwpn, sizeof (s_rwwpn),
8524 (uint8_t *)&auth_key->remote_entity),
8536 auth_key->local_password_type, auth_key->local_password_length,
8537 auth_key->remote_password_type, auth_key->remote_password_length);
8538
8539 return;
8540
8541} /* emlxs_auth_key_print() */
8542
8543

--- 117 unchanged lines hidden (view full) ---

8661 emlxs_auth_key_t *auth_key2;
8662 uint32_t cnt;
8663 uint32_t rval;
8664 char buffer[64];
8665 char *prop_str;
8666 uint32_t i;
8667
8668 /* Check for the per adapter setting */
8525 auth_key->local_password_type, auth_key->local_password_length,
8526 auth_key->remote_password_type, auth_key->remote_password_length);
8527
8528 return;
8529
8530} /* emlxs_auth_key_print() */
8531
8532

--- 117 unchanged lines hidden (view full) ---

8650 emlxs_auth_key_t *auth_key2;
8651 uint32_t cnt;
8652 uint32_t rval;
8653 char buffer[64];
8654 char *prop_str;
8655 uint32_t i;
8656
8657 /* Check for the per adapter setting */
8669 (void) sprintf(buffer, "%s%d-auth-keys", DRIVER_NAME, hba->ddiinst);
8658 (void) snprintf(buffer, sizeof (buffer), "%s%d-auth-keys", DRIVER_NAME,
8659 hba->ddiinst);
8670 cnt = 0;
8671 arrayp = NULL;
8672 rval = ddi_prop_lookup_string_array(DDI_DEV_T_ANY, hba->dip,
8673 (DDI_PROP_DONTPASS),
8674 buffer, &arrayp, &cnt);
8675
8676 if ((rval != DDI_PROP_SUCCESS) || !cnt || !arrayp) {
8677 /* Check for the global setting */

--- 380 unchanged lines hidden (view full) ---

9058 NODELIST *ndlp;
9059 uint32_t vpi;
9060 char s_wwpn[64];
9061
9062 /* Return is authentication is not enabled */
9063 if (cfg[CFG_AUTH_ENABLE].current == 0) {
9064 EMLXS_MSGF(EMLXS_CONTEXT,
9065 &emlxs_fcsp_debug_msg,
8660 cnt = 0;
8661 arrayp = NULL;
8662 rval = ddi_prop_lookup_string_array(DDI_DEV_T_ANY, hba->dip,
8663 (DDI_PROP_DONTPASS),
8664 buffer, &arrayp, &cnt);
8665
8666 if ((rval != DDI_PROP_SUCCESS) || !cnt || !arrayp) {
8667 /* Check for the global setting */

--- 380 unchanged lines hidden (view full) ---

9048 NODELIST *ndlp;
9049 uint32_t vpi;
9050 char s_wwpn[64];
9051
9052 /* Return is authentication is not enabled */
9053 if (cfg[CFG_AUTH_ENABLE].current == 0) {
9054 EMLXS_MSGF(EMLXS_CONTEXT,
9055 &emlxs_fcsp_debug_msg,
9066 "emlxs_dhc_init_auth. Auth disabled.");
9056 "dhc_init_auth. Auth disabled.");
9067
9068 return (DFC_AUTH_AUTHENTICATION_DISABLED);
9069 }
9070 /* Scan for lwwpn match */
9071 for (vpi = 0; vpi < MAX_VPORTS; vpi++) {
9072 port = &VPORT(vpi);
9073
9074 if (!(port->flag & EMLXS_PORT_BOUND)) {
9075 continue;
9076 }
9077 if (bcmp((uint8_t *)&port->wwpn, lwwpn, 8) == 0) {
9078 break;
9079 }
9080 }
9081
9082 if (vpi == MAX_VPORTS) {
9083 EMLXS_MSGF(EMLXS_CONTEXT,
9084 &emlxs_dfc_error_msg,
9057
9058 return (DFC_AUTH_AUTHENTICATION_DISABLED);
9059 }
9060 /* Scan for lwwpn match */
9061 for (vpi = 0; vpi < MAX_VPORTS; vpi++) {
9062 port = &VPORT(vpi);
9063
9064 if (!(port->flag & EMLXS_PORT_BOUND)) {
9065 continue;
9066 }
9067 if (bcmp((uint8_t *)&port->wwpn, lwwpn, 8) == 0) {
9068 break;
9069 }
9070 }
9071
9072 if (vpi == MAX_VPORTS) {
9073 EMLXS_MSGF(EMLXS_CONTEXT,
9074 &emlxs_dfc_error_msg,
9085 "emlxs_dhc_init_auth: lwwpn not found. %s",
9086 emlxs_wwn_xlate(s_wwpn, lwwpn));
9075 "dhc_init_auth: lwwpn not found. %s",
9076 emlxs_wwn_xlate(s_wwpn, sizeof (s_wwpn), lwwpn));
9087
9088 return (DFC_AUTH_WWN_NOT_FOUND);
9089 }
9090 if (bcmp(rwwpn, emlxs_fabric_wwn, 8) == 0) {
9091 /* Scan for fabric node */
9077
9078 return (DFC_AUTH_WWN_NOT_FOUND);
9079 }
9080 if (bcmp(rwwpn, emlxs_fabric_wwn, 8) == 0) {
9081 /* Scan for fabric node */
9092 if ((ndlp = emlxs_node_find_did(port, FABRIC_DID)) == NULL) {
9082 if ((ndlp = emlxs_node_find_did(port, FABRIC_DID, 1)) == NULL) {
9093 EMLXS_MSGF(EMLXS_CONTEXT,
9094 &emlxs_dfc_error_msg,
9083 EMLXS_MSGF(EMLXS_CONTEXT,
9084 &emlxs_dfc_error_msg,
9095 "emlxs_dhc_init_auth: fabric node not found.");
9085 "dhc_init_auth: fabric node not found.");
9096
9097 return (DFC_AUTH_WWN_NOT_FOUND);
9098 }
9099 } else {
9100 /* Scan for rwwpn match */
9086
9087 return (DFC_AUTH_WWN_NOT_FOUND);
9088 }
9089 } else {
9090 /* Scan for rwwpn match */
9101 if ((ndlp = emlxs_node_find_wwpn(port, rwwpn)) == NULL) {
9091 if ((ndlp = emlxs_node_find_wwpn(port, rwwpn, 1)) == NULL) {
9102 EMLXS_MSGF(EMLXS_CONTEXT,
9103 &emlxs_dfc_error_msg,
9092 EMLXS_MSGF(EMLXS_CONTEXT,
9093 &emlxs_dfc_error_msg,
9104 "emlxs_dhc_init_auth: rwwpn not found. %s",
9105 emlxs_wwn_xlate(s_wwpn, rwwpn));
9094 "dhc_init_auth: rwwpn not found. %s",
9095 emlxs_wwn_xlate(s_wwpn, sizeof (s_wwpn), rwwpn));
9106
9107 return (DFC_AUTH_WWN_NOT_FOUND);
9108 }
9109 }
9110
9111 if ((ndlp->nlp_DID != FABRIC_DID) &&
9112 ((port->port_dhc.state != ELX_FABRIC_AUTH_SUCCESS))) {
9113 return (DFC_IO_ERROR);

--- 23 unchanged lines hidden (view full) ---

9137 char s_rwwpn[64];
9138 emlxs_auth_cfg_t *auth_cfg;
9139 uint32_t i;
9140
9141 /* Return is authentication is not enabled */
9142 if (cfg[CFG_AUTH_ENABLE].current == 0) {
9143 EMLXS_MSGF(EMLXS_CONTEXT,
9144 &emlxs_fcsp_debug_msg,
9096
9097 return (DFC_AUTH_WWN_NOT_FOUND);
9098 }
9099 }
9100
9101 if ((ndlp->nlp_DID != FABRIC_DID) &&
9102 ((port->port_dhc.state != ELX_FABRIC_AUTH_SUCCESS))) {
9103 return (DFC_IO_ERROR);

--- 23 unchanged lines hidden (view full) ---

9127 char s_rwwpn[64];
9128 emlxs_auth_cfg_t *auth_cfg;
9129 uint32_t i;
9130
9131 /* Return is authentication is not enabled */
9132 if (cfg[CFG_AUTH_ENABLE].current == 0) {
9133 EMLXS_MSGF(EMLXS_CONTEXT,
9134 &emlxs_fcsp_debug_msg,
9145 "emlxs_dhc_get_auth_cfg. Auth disabled.");
9135 "dhc_get_auth_cfg. Auth disabled.");
9146
9147 return (DFC_AUTH_AUTHENTICATION_DISABLED);
9148 }
9149 mutex_enter(&hba->auth_lock);
9150
9151 auth_cfg = emlxs_auth_cfg_get(hba,
9152 (uint8_t *)&fcsp_cfg->lwwpn, (uint8_t *)&fcsp_cfg->rwwpn);
9153
9154 if (!auth_cfg) {
9155 EMLXS_MSGF(EMLXS_CONTEXT,
9156 &emlxs_dfc_error_msg,
9136
9137 return (DFC_AUTH_AUTHENTICATION_DISABLED);
9138 }
9139 mutex_enter(&hba->auth_lock);
9140
9141 auth_cfg = emlxs_auth_cfg_get(hba,
9142 (uint8_t *)&fcsp_cfg->lwwpn, (uint8_t *)&fcsp_cfg->rwwpn);
9143
9144 if (!auth_cfg) {
9145 EMLXS_MSGF(EMLXS_CONTEXT,
9146 &emlxs_dfc_error_msg,
9157 "emlxs_dhc_get_auth_cfg: entry not found. %s:%s",
9158 emlxs_wwn_xlate(s_lwwpn,
9147 "dhc_get_auth_cfg: entry not found. %s:%s",
9148 emlxs_wwn_xlate(s_lwwpn, sizeof (s_lwwpn),
9159 (uint8_t *)&fcsp_cfg->lwwpn),
9149 (uint8_t *)&fcsp_cfg->lwwpn),
9160 emlxs_wwn_xlate(s_rwwpn,
9150 emlxs_wwn_xlate(s_rwwpn, sizeof (s_rwwpn),
9161 (uint8_t *)&fcsp_cfg->rwwpn));
9162
9163 mutex_exit(&hba->auth_lock);
9164
9165 return (DFC_AUTH_NOT_CONFIGURED);
9166 }
9167 fcsp_cfg->auth_tov = auth_cfg->authentication_timeout;
9168 fcsp_cfg->auth_mode = auth_cfg->authentication_mode;

--- 32 unchanged lines hidden (view full) ---

9201 emlxs_auth_key_t *auth_key;
9202 uint32_t i;
9203 NODELIST *ndlp;
9204
9205 /* Return if authentication is not enabled */
9206 if (cfg[CFG_AUTH_ENABLE].current == 0) {
9207 EMLXS_MSGF(EMLXS_CONTEXT,
9208 &emlxs_fcsp_debug_msg,
9151 (uint8_t *)&fcsp_cfg->rwwpn));
9152
9153 mutex_exit(&hba->auth_lock);
9154
9155 return (DFC_AUTH_NOT_CONFIGURED);
9156 }
9157 fcsp_cfg->auth_tov = auth_cfg->authentication_timeout;
9158 fcsp_cfg->auth_mode = auth_cfg->authentication_mode;

--- 32 unchanged lines hidden (view full) ---

9191 emlxs_auth_key_t *auth_key;
9192 uint32_t i;
9193 NODELIST *ndlp;
9194
9195 /* Return if authentication is not enabled */
9196 if (cfg[CFG_AUTH_ENABLE].current == 0) {
9197 EMLXS_MSGF(EMLXS_CONTEXT,
9198 &emlxs_fcsp_debug_msg,
9209 "emlxs_dhc_add_auth_cfg. Auth disabled.");
9199 "dhc_add_auth_cfg. Auth disabled.");
9210
9211 return (DFC_AUTH_AUTHENTICATION_DISABLED);
9212 }
9213 mutex_enter(&hba->auth_lock);
9214
9215 auth_key = emlxs_auth_key_get(hba,
9216 (uint8_t *)&fcsp_cfg->lwwpn, (uint8_t *)&fcsp_cfg->rwwpn);
9217
9218 if (auth_key &&
9219 (auth_key->local_password_type == PASSWORD_TYPE_ASCII ||
9220 auth_key->local_password_type == PASSWORD_TYPE_BINARY)) {
9221
9222 /* Verify local password */
9223 if ((auth_key->local_password_length != dfc_pwd->length) ||
9224 (auth_key->local_password_type != dfc_pwd->type) ||
9225 bcmp(dfc_pwd->password, auth_key->local_password,
9226 dfc_pwd->length)) {
9227 EMLXS_MSGF(EMLXS_CONTEXT,
9228 &emlxs_dfc_error_msg,
9200
9201 return (DFC_AUTH_AUTHENTICATION_DISABLED);
9202 }
9203 mutex_enter(&hba->auth_lock);
9204
9205 auth_key = emlxs_auth_key_get(hba,
9206 (uint8_t *)&fcsp_cfg->lwwpn, (uint8_t *)&fcsp_cfg->rwwpn);
9207
9208 if (auth_key &&
9209 (auth_key->local_password_type == PASSWORD_TYPE_ASCII ||
9210 auth_key->local_password_type == PASSWORD_TYPE_BINARY)) {
9211
9212 /* Verify local password */
9213 if ((auth_key->local_password_length != dfc_pwd->length) ||
9214 (auth_key->local_password_type != dfc_pwd->type) ||
9215 bcmp(dfc_pwd->password, auth_key->local_password,
9216 dfc_pwd->length)) {
9217 EMLXS_MSGF(EMLXS_CONTEXT,
9218 &emlxs_dfc_error_msg,
9229 "emlxs_dhc_add_auth_cfg: Invalid local password.");
9219 "dhc_add_auth_cfg: Invalid local password.");
9230
9231 mutex_exit(&hba->auth_lock);
9232
9233 return (DFC_AUTH_COMPARE_FAILED);
9234 }
9235 }
9236 /* Create entry */
9237 auth_cfg = emlxs_auth_cfg_create(hba,
9238 (uint8_t *)&fcsp_cfg->lwwpn,
9239 (uint8_t *)&fcsp_cfg->rwwpn);
9240
9241 if (!auth_cfg) {
9242 EMLXS_MSGF(EMLXS_CONTEXT,
9243 &emlxs_dfc_error_msg,
9220
9221 mutex_exit(&hba->auth_lock);
9222
9223 return (DFC_AUTH_COMPARE_FAILED);
9224 }
9225 }
9226 /* Create entry */
9227 auth_cfg = emlxs_auth_cfg_create(hba,
9228 (uint8_t *)&fcsp_cfg->lwwpn,
9229 (uint8_t *)&fcsp_cfg->rwwpn);
9230
9231 if (!auth_cfg) {
9232 EMLXS_MSGF(EMLXS_CONTEXT,
9233 &emlxs_dfc_error_msg,
9244 "emlxs_dhc_add_auth_cfg: Out of memory.");
9234 "dhc_add_auth_cfg: Out of memory.");
9245
9246 mutex_exit(&hba->auth_lock);
9247
9248 return (DFC_SYSRES_ERROR);
9249 }
9250 /* Init entry */
9251 auth_cfg->authentication_timeout = fcsp_cfg->auth_tov;
9252 auth_cfg->authentication_mode = fcsp_cfg->auth_mode;

--- 28 unchanged lines hidden (view full) ---

9281 continue;
9282 }
9283 /* Port match found */
9284
9285 if (bcmp((uint8_t *)&fcsp_cfg->rwwpn,
9286 emlxs_fabric_wwn, 8) == 0) {
9287 /* Scan for fabric node */
9288 if ((ndlp = emlxs_node_find_did(port,
9235
9236 mutex_exit(&hba->auth_lock);
9237
9238 return (DFC_SYSRES_ERROR);
9239 }
9240 /* Init entry */
9241 auth_cfg->authentication_timeout = fcsp_cfg->auth_tov;
9242 auth_cfg->authentication_mode = fcsp_cfg->auth_mode;

--- 28 unchanged lines hidden (view full) ---

9271 continue;
9272 }
9273 /* Port match found */
9274
9275 if (bcmp((uint8_t *)&fcsp_cfg->rwwpn,
9276 emlxs_fabric_wwn, 8) == 0) {
9277 /* Scan for fabric node */
9278 if ((ndlp = emlxs_node_find_did(port,
9289 FABRIC_DID)) == NULL) {
9279 FABRIC_DID, 1)) == NULL) {
9290 break;
9291 }
9292 } else {
9293 /* Scan for rwwpn match */
9294 if ((ndlp = emlxs_node_find_wwpn(port,
9280 break;
9281 }
9282 } else {
9283 /* Scan for rwwpn match */
9284 if ((ndlp = emlxs_node_find_wwpn(port,
9295 (uint8_t *)&fcsp_cfg->rwwpn)) == NULL) {
9285 (uint8_t *)&fcsp_cfg->rwwpn, 1)) == NULL) {
9296 break;
9297 }
9298 }
9299
9300 emlxs_dhc_set_reauth_time(port, ndlp, ENABLE);
9301
9302 break;
9303 }

--- 18 unchanged lines hidden (view full) ---

9322 char s_rwwpn[64];
9323 emlxs_auth_key_t *auth_key;
9324 emlxs_auth_cfg_t *auth_cfg;
9325
9326 /* Return is authentication is not enabled */
9327 if (cfg[CFG_AUTH_ENABLE].current == 0) {
9328 EMLXS_MSGF(EMLXS_CONTEXT,
9329 &emlxs_fcsp_debug_msg,
9286 break;
9287 }
9288 }
9289
9290 emlxs_dhc_set_reauth_time(port, ndlp, ENABLE);
9291
9292 break;
9293 }

--- 18 unchanged lines hidden (view full) ---

9312 char s_rwwpn[64];
9313 emlxs_auth_key_t *auth_key;
9314 emlxs_auth_cfg_t *auth_cfg;
9315
9316 /* Return is authentication is not enabled */
9317 if (cfg[CFG_AUTH_ENABLE].current == 0) {
9318 EMLXS_MSGF(EMLXS_CONTEXT,
9319 &emlxs_fcsp_debug_msg,
9330 "emlxs_dhc_delete_auth_cfg. Auth disabled.");
9320 "dhc_delete_auth_cfg. Auth disabled.");
9331
9332 return (DFC_AUTH_AUTHENTICATION_DISABLED);
9333 }
9334 mutex_enter(&hba->auth_lock);
9335
9336 auth_key = emlxs_auth_key_get(hba,
9337 (uint8_t *)&fcsp_cfg->lwwpn,
9338 (uint8_t *)&fcsp_cfg->rwwpn);

--- 6 unchanged lines hidden (view full) ---

9345 if ((auth_key->local_password_length != dfc_pwd->length) ||
9346 (auth_key->local_password_type != dfc_pwd->type) ||
9347 bcmp(dfc_pwd->password,
9348 auth_key->local_password,
9349 dfc_pwd->length)) {
9350
9351 EMLXS_MSGF(EMLXS_CONTEXT,
9352 &emlxs_dfc_error_msg,
9321
9322 return (DFC_AUTH_AUTHENTICATION_DISABLED);
9323 }
9324 mutex_enter(&hba->auth_lock);
9325
9326 auth_key = emlxs_auth_key_get(hba,
9327 (uint8_t *)&fcsp_cfg->lwwpn,
9328 (uint8_t *)&fcsp_cfg->rwwpn);

--- 6 unchanged lines hidden (view full) ---

9335 if ((auth_key->local_password_length != dfc_pwd->length) ||
9336 (auth_key->local_password_type != dfc_pwd->type) ||
9337 bcmp(dfc_pwd->password,
9338 auth_key->local_password,
9339 dfc_pwd->length)) {
9340
9341 EMLXS_MSGF(EMLXS_CONTEXT,
9342 &emlxs_dfc_error_msg,
9353 "emlxs_dhc_delete_auth_cfg: Ivld local pwd.");
9343 "dhc_delete_auth_cfg: Ivld local pwd.");
9354
9355 mutex_exit(&hba->auth_lock);
9356
9357 return (DFC_AUTH_COMPARE_FAILED);
9358 }
9359 }
9360 auth_cfg = emlxs_auth_cfg_get(hba,
9361 (uint8_t *)&fcsp_cfg->lwwpn, (uint8_t *)&fcsp_cfg->rwwpn);
9362
9363 if (!auth_cfg) {
9364 EMLXS_MSGF(EMLXS_CONTEXT,
9365 &emlxs_dfc_error_msg,
9344
9345 mutex_exit(&hba->auth_lock);
9346
9347 return (DFC_AUTH_COMPARE_FAILED);
9348 }
9349 }
9350 auth_cfg = emlxs_auth_cfg_get(hba,
9351 (uint8_t *)&fcsp_cfg->lwwpn, (uint8_t *)&fcsp_cfg->rwwpn);
9352
9353 if (!auth_cfg) {
9354 EMLXS_MSGF(EMLXS_CONTEXT,
9355 &emlxs_dfc_error_msg,
9366 "emlxs_dhc_delete_auth_cfg: entry not found. %s:%s",
9367 emlxs_wwn_xlate(s_lwwpn, (uint8_t *)&fcsp_cfg->lwwpn),
9368 emlxs_wwn_xlate(s_rwwpn, (uint8_t *)&fcsp_cfg->rwwpn));
9356 "dhc_delete_auth_cfg: entry not found. %s:%s",
9357 emlxs_wwn_xlate(s_lwwpn, sizeof (s_lwwpn),
9358 (uint8_t *)&fcsp_cfg->lwwpn),
9359 emlxs_wwn_xlate(s_rwwpn, sizeof (s_rwwpn),
9360 (uint8_t *)&fcsp_cfg->rwwpn));
9369
9370 mutex_exit(&hba->auth_lock);
9371
9372 return (DFC_AUTH_WWN_NOT_FOUND);
9373 }
9374 /* Destroy cfg entry */
9375 emlxs_auth_cfg_destroy(hba, auth_cfg);
9376

--- 16 unchanged lines hidden (view full) ---

9393 char s_lwwpn[64];
9394 char s_rwwpn[64];
9395 emlxs_auth_key_t *auth_key;
9396
9397 /* Return is authentication is not enabled */
9398 if (cfg[CFG_AUTH_ENABLE].current == 0) {
9399 EMLXS_MSGF(EMLXS_CONTEXT,
9400 &emlxs_fcsp_debug_msg,
9361
9362 mutex_exit(&hba->auth_lock);
9363
9364 return (DFC_AUTH_WWN_NOT_FOUND);
9365 }
9366 /* Destroy cfg entry */
9367 emlxs_auth_cfg_destroy(hba, auth_cfg);
9368

--- 16 unchanged lines hidden (view full) ---

9385 char s_lwwpn[64];
9386 char s_rwwpn[64];
9387 emlxs_auth_key_t *auth_key;
9388
9389 /* Return is authentication is not enabled */
9390 if (cfg[CFG_AUTH_ENABLE].current == 0) {
9391 EMLXS_MSGF(EMLXS_CONTEXT,
9392 &emlxs_fcsp_debug_msg,
9401 "emlxs_dhc_get_auth_key. Auth disabled.");
9393 "dhc_get_auth_key. Auth disabled.");
9402
9403 return (DFC_AUTH_AUTHENTICATION_DISABLED);
9404 }
9405 mutex_enter(&hba->auth_lock);
9406
9407 auth_key = emlxs_auth_key_get(hba,
9408 (uint8_t *)&dfc_auth_pwd->lwwpn,
9409 (uint8_t *)&dfc_auth_pwd->rwwpn);
9410
9411 if (!auth_key) {
9412 EMLXS_MSGF(EMLXS_CONTEXT,
9413 &emlxs_dfc_error_msg,
9394
9395 return (DFC_AUTH_AUTHENTICATION_DISABLED);
9396 }
9397 mutex_enter(&hba->auth_lock);
9398
9399 auth_key = emlxs_auth_key_get(hba,
9400 (uint8_t *)&dfc_auth_pwd->lwwpn,
9401 (uint8_t *)&dfc_auth_pwd->rwwpn);
9402
9403 if (!auth_key) {
9404 EMLXS_MSGF(EMLXS_CONTEXT,
9405 &emlxs_dfc_error_msg,
9414 "emlxs_dhc_get_auth_key: entry not found. %s:%s",
9415 emlxs_wwn_xlate(s_lwwpn, (uint8_t *)&dfc_auth_pwd->lwwpn),
9416 emlxs_wwn_xlate(s_rwwpn, (uint8_t *)&dfc_auth_pwd->rwwpn));
9406 "dhc_get_auth_key: entry not found. %s:%s",
9407 emlxs_wwn_xlate(s_lwwpn, sizeof (s_lwwpn),
9408 (uint8_t *)&dfc_auth_pwd->lwwpn),
9409 emlxs_wwn_xlate(s_rwwpn, sizeof (s_rwwpn),
9410 (uint8_t *)&dfc_auth_pwd->rwwpn));
9417
9418 mutex_exit(&hba->auth_lock);
9419
9420 return (DFC_AUTH_NOT_CONFIGURED);
9421 }
9422 dfc_auth_pwd->lpw.length = auth_key->local_password_length;
9423 dfc_auth_pwd->lpw.type = auth_key->local_password_type;
9424 /*

--- 37 unchanged lines hidden (view full) ---

9462 emlxs_config_t *cfg = &CFG;
9463 emlxs_auth_key_t *auth_key;
9464 uint32_t length;
9465
9466 /* Return is authentication is not enabled */
9467 if (cfg[CFG_AUTH_ENABLE].current == 0) {
9468 EMLXS_MSGF(EMLXS_CONTEXT,
9469 &emlxs_fcsp_debug_msg,
9411
9412 mutex_exit(&hba->auth_lock);
9413
9414 return (DFC_AUTH_NOT_CONFIGURED);
9415 }
9416 dfc_auth_pwd->lpw.length = auth_key->local_password_length;
9417 dfc_auth_pwd->lpw.type = auth_key->local_password_type;
9418 /*

--- 37 unchanged lines hidden (view full) ---

9456 emlxs_config_t *cfg = &CFG;
9457 emlxs_auth_key_t *auth_key;
9458 uint32_t length;
9459
9460 /* Return is authentication is not enabled */
9461 if (cfg[CFG_AUTH_ENABLE].current == 0) {
9462 EMLXS_MSGF(EMLXS_CONTEXT,
9463 &emlxs_fcsp_debug_msg,
9470 "emlxs_dhc_set_auth_key. Auth disabled.");
9464 "dhc_set_auth_key. Auth disabled.");
9471
9472 return (DFC_AUTH_AUTHENTICATION_DISABLED);
9473 }
9474
9475 /* Check to make sure localpwd does not equal to remotepwd */
9476 /* if they are given in the same time, if not, see below */
9477 if ((dfc_pwd->lpw_new.type == PASSWORD_TYPE_ASCII ||
9478 dfc_pwd->lpw_new.type == PASSWORD_TYPE_BINARY) &&
9479 (dfc_pwd->rpw_new.type == PASSWORD_TYPE_ASCII ||
9480 dfc_pwd->rpw_new.type == PASSWORD_TYPE_BINARY)) {
9481 if (bcmp(dfc_pwd->lpw_new.password,
9482 dfc_pwd->rpw_new.password,
9483 dfc_pwd->lpw_new.length) == 0) {
9484 EMLXS_MSGF(EMLXS_CONTEXT,
9485 &emlxs_fcsp_debug_msg,
9465
9466 return (DFC_AUTH_AUTHENTICATION_DISABLED);
9467 }
9468
9469 /* Check to make sure localpwd does not equal to remotepwd */
9470 /* if they are given in the same time, if not, see below */
9471 if ((dfc_pwd->lpw_new.type == PASSWORD_TYPE_ASCII ||
9472 dfc_pwd->lpw_new.type == PASSWORD_TYPE_BINARY) &&
9473 (dfc_pwd->rpw_new.type == PASSWORD_TYPE_ASCII ||
9474 dfc_pwd->rpw_new.type == PASSWORD_TYPE_BINARY)) {
9475 if (bcmp(dfc_pwd->lpw_new.password,
9476 dfc_pwd->rpw_new.password,
9477 dfc_pwd->lpw_new.length) == 0) {
9478 EMLXS_MSGF(EMLXS_CONTEXT,
9479 &emlxs_fcsp_debug_msg,
9486 "emlxs_dhc_set_auth_key. nlpwd==nrpwd");
9480 "dhc_set_auth_key. nlpwd==nrpwd");
9487
9488 return (DFC_AUTH_LOCAL_REMOTE_PWD_EQUAL);
9489 }
9490 }
9491
9492 mutex_enter(&hba->auth_lock);
9493
9494 auth_key = emlxs_auth_key_get(hba,

--- 4 unchanged lines hidden (view full) ---

9499 if (!auth_key) {
9500 auth_key = emlxs_auth_key_create(hba,
9501 (uint8_t *)&dfc_pwd->lwwpn,
9502 (uint8_t *)&dfc_pwd->rwwpn);
9503
9504 if (!auth_key) {
9505 EMLXS_MSGF(EMLXS_CONTEXT,
9506 &emlxs_dfc_error_msg,
9481
9482 return (DFC_AUTH_LOCAL_REMOTE_PWD_EQUAL);
9483 }
9484 }
9485
9486 mutex_enter(&hba->auth_lock);
9487
9488 auth_key = emlxs_auth_key_get(hba,

--- 4 unchanged lines hidden (view full) ---

9493 if (!auth_key) {
9494 auth_key = emlxs_auth_key_create(hba,
9495 (uint8_t *)&dfc_pwd->lwwpn,
9496 (uint8_t *)&dfc_pwd->rwwpn);
9497
9498 if (!auth_key) {
9499 EMLXS_MSGF(EMLXS_CONTEXT,
9500 &emlxs_dfc_error_msg,
9507 "emlxs_dhc_set_auth_key: Out of memory.");
9501 "dhc_set_auth_key: Out of memory.");
9508
9509 mutex_exit(&hba->auth_lock);
9510
9511 return (DFC_SYSRES_ERROR);
9512 }
9513 }
9514
9515 /* Check if a new local password is provided */

--- 7 unchanged lines hidden (view full) ---

9523 dfc_pwd->lpw.length) ||
9524 (auth_key->local_password_type !=
9525 dfc_pwd->lpw.type) ||
9526 bcmp(dfc_pwd->lpw.password,
9527 auth_key->local_password,
9528 dfc_pwd->lpw.length)) {
9529 EMLXS_MSGF(EMLXS_CONTEXT,
9530 &emlxs_dfc_error_msg,
9502
9503 mutex_exit(&hba->auth_lock);
9504
9505 return (DFC_SYSRES_ERROR);
9506 }
9507 }
9508
9509 /* Check if a new local password is provided */

--- 7 unchanged lines hidden (view full) ---

9517 dfc_pwd->lpw.length) ||
9518 (auth_key->local_password_type !=
9519 dfc_pwd->lpw.type) ||
9520 bcmp(dfc_pwd->lpw.password,
9521 auth_key->local_password,
9522 dfc_pwd->lpw.length)) {
9523 EMLXS_MSGF(EMLXS_CONTEXT,
9524 &emlxs_dfc_error_msg,
9531 "emlxs_dhc_set_auth_key: Invalid local password.");
9525 "dhc_set_auth_key: Invalid local password.");
9532
9533 mutex_exit(&hba->auth_lock);
9534
9535 return (DFC_AUTH_COMPARE_FAILED);
9536 }
9537 }
9538
9539 /*

--- 4 unchanged lines hidden (view full) ---

9544 auth_key->remote_password_type == PASSWORD_TYPE_BINARY) {
9545 if ((auth_key->remote_password_length ==
9546 dfc_pwd->lpw_new.length) &&
9547 (bcmp(dfc_pwd->lpw_new.password,
9548 auth_key->remote_password,
9549 dfc_pwd->lpw_new.length) == 0)) {
9550 EMLXS_MSGF(EMLXS_CONTEXT,
9551 &emlxs_dfc_error_msg,
9526
9527 mutex_exit(&hba->auth_lock);
9528
9529 return (DFC_AUTH_COMPARE_FAILED);
9530 }
9531 }
9532
9533 /*

--- 4 unchanged lines hidden (view full) ---

9538 auth_key->remote_password_type == PASSWORD_TYPE_BINARY) {
9539 if ((auth_key->remote_password_length ==
9540 dfc_pwd->lpw_new.length) &&
9541 (bcmp(dfc_pwd->lpw_new.password,
9542 auth_key->remote_password,
9543 dfc_pwd->lpw_new.length) == 0)) {
9544 EMLXS_MSGF(EMLXS_CONTEXT,
9545 &emlxs_dfc_error_msg,
9552 "emlxs_dhc_set_auth_key: nlpwd==crpwd");
9546 "dhc_set_auth_key: nlpwd==crpwd");
9553
9554 mutex_exit(&hba->auth_lock);
9555
9556 return (DFC_AUTH_LOCAL_REMOTE_PWD_EQUAL);
9557 }
9558 }
9559 /* Update local entry */
9560 auth_key->local_password_length = dfc_pwd->lpw_new.length;

--- 16 unchanged lines hidden (view full) ---

9577 dfc_pwd->rpw.length) ||
9578 (auth_key->remote_password_type !=
9579 dfc_pwd->rpw.type) ||
9580 bcmp(dfc_pwd->rpw.password,
9581 auth_key->remote_password,
9582 dfc_pwd->rpw.length)) {
9583 EMLXS_MSGF(EMLXS_CONTEXT,
9584 &emlxs_dfc_error_msg,
9547
9548 mutex_exit(&hba->auth_lock);
9549
9550 return (DFC_AUTH_LOCAL_REMOTE_PWD_EQUAL);
9551 }
9552 }
9553 /* Update local entry */
9554 auth_key->local_password_length = dfc_pwd->lpw_new.length;

--- 16 unchanged lines hidden (view full) ---

9571 dfc_pwd->rpw.length) ||
9572 (auth_key->remote_password_type !=
9573 dfc_pwd->rpw.type) ||
9574 bcmp(dfc_pwd->rpw.password,
9575 auth_key->remote_password,
9576 dfc_pwd->rpw.length)) {
9577 EMLXS_MSGF(EMLXS_CONTEXT,
9578 &emlxs_dfc_error_msg,
9585 "emlxs_dhc_set_auth_key: Invalid remote password.");
9579 "dhc_set_auth_key: Invalid remote password.");
9586
9587 mutex_exit(&hba->auth_lock);
9588
9589 return (DFC_AUTH_COMPARE_FAILED);
9590 }
9591 }
9592
9593 /*

--- 4 unchanged lines hidden (view full) ---

9598 auth_key->local_password_type == PASSWORD_TYPE_BINARY) {
9599 if ((auth_key->local_password_length ==
9600 dfc_pwd->rpw_new.length) &&
9601 (bcmp(dfc_pwd->rpw_new.password,
9602 auth_key->local_password,
9603 dfc_pwd->rpw_new.length) == 0)) {
9604 EMLXS_MSGF(EMLXS_CONTEXT,
9605 &emlxs_dfc_error_msg,
9580
9581 mutex_exit(&hba->auth_lock);
9582
9583 return (DFC_AUTH_COMPARE_FAILED);
9584 }
9585 }
9586
9587 /*

--- 4 unchanged lines hidden (view full) ---

9592 auth_key->local_password_type == PASSWORD_TYPE_BINARY) {
9593 if ((auth_key->local_password_length ==
9594 dfc_pwd->rpw_new.length) &&
9595 (bcmp(dfc_pwd->rpw_new.password,
9596 auth_key->local_password,
9597 dfc_pwd->rpw_new.length) == 0)) {
9598 EMLXS_MSGF(EMLXS_CONTEXT,
9599 &emlxs_dfc_error_msg,
9606 "emlxs_dhc_set_auth_key: nrpwd==clpwd");
9600 "dhc_set_auth_key: nrpwd==clpwd");
9607
9608 mutex_exit(&hba->auth_lock);
9609
9610 return (DFC_AUTH_LOCAL_REMOTE_PWD_EQUAL);
9611 }
9612 }
9613 /* Update remote entry */
9614 auth_key->remote_password_length = dfc_pwd->rpw_new.length;

--- 42 unchanged lines hidden (view full) ---

9657 NODELIST *ndlp;
9658 uint32_t rc;
9659 time_t auth_time;
9660 uint32_t update;
9661
9662 /* Return is authentication is not enabled */
9663 if (cfg[CFG_AUTH_ENABLE].current == 0) {
9664 EMLXS_MSGF(EMLXS_CONTEXT, &emlxs_fcsp_debug_msg,
9601
9602 mutex_exit(&hba->auth_lock);
9603
9604 return (DFC_AUTH_LOCAL_REMOTE_PWD_EQUAL);
9605 }
9606 }
9607 /* Update remote entry */
9608 auth_key->remote_password_length = dfc_pwd->rpw_new.length;

--- 42 unchanged lines hidden (view full) ---

9651 NODELIST *ndlp;
9652 uint32_t rc;
9653 time_t auth_time;
9654 uint32_t update;
9655
9656 /* Return is authentication is not enabled */
9657 if (cfg[CFG_AUTH_ENABLE].current == 0) {
9658 EMLXS_MSGF(EMLXS_CONTEXT, &emlxs_fcsp_debug_msg,
9665 "emlxs_dhc_get_auth_status. Auth disabled.");
9659 "dhc_get_auth_status. Auth disabled.");
9666
9667 return (DFC_AUTH_AUTHENTICATION_DISABLED);
9668 }
9669 mutex_enter(&hba->auth_lock);
9670
9671 auth_cfg = emlxs_auth_cfg_get(hba, (uint8_t *)&fcsp_status->lwwpn,
9672 (uint8_t *)&fcsp_status->rwwpn);
9673
9674 if (!auth_cfg) {
9675 EMLXS_MSGF(EMLXS_CONTEXT, &emlxs_dfc_error_msg,
9660
9661 return (DFC_AUTH_AUTHENTICATION_DISABLED);
9662 }
9663 mutex_enter(&hba->auth_lock);
9664
9665 auth_cfg = emlxs_auth_cfg_get(hba, (uint8_t *)&fcsp_status->lwwpn,
9666 (uint8_t *)&fcsp_status->rwwpn);
9667
9668 if (!auth_cfg) {
9669 EMLXS_MSGF(EMLXS_CONTEXT, &emlxs_dfc_error_msg,
9676 "emlxs_dhc_get_auth_status: entry not found. %s:%s",
9677 emlxs_wwn_xlate(s_lwwpn, (uint8_t *)&fcsp_status->lwwpn),
9678 emlxs_wwn_xlate(s_rwwpn, (uint8_t *)&fcsp_status->rwwpn));
9670 "dhc_get_auth_status: entry not found. %s:%s",
9671 emlxs_wwn_xlate(s_lwwpn, sizeof (s_lwwpn),
9672 (uint8_t *)&fcsp_status->lwwpn),
9673 emlxs_wwn_xlate(s_rwwpn, sizeof (s_rwwpn),
9674 (uint8_t *)&fcsp_status->rwwpn));
9679
9680 mutex_exit(&hba->auth_lock);
9681
9682 return (DFC_AUTH_NOT_CONFIGURED);
9683 }
9684 if (bcmp((uint8_t *)&fcsp_status->rwwpn,
9685 (uint8_t *)emlxs_fabric_wwn, 8) == 0) {
9686 auth_status = &port->port_dhc.auth_status;
9687 auth_time = port->port_dhc.auth_time;
9675
9676 mutex_exit(&hba->auth_lock);
9677
9678 return (DFC_AUTH_NOT_CONFIGURED);
9679 }
9680 if (bcmp((uint8_t *)&fcsp_status->rwwpn,
9681 (uint8_t *)emlxs_fabric_wwn, 8) == 0) {
9682 auth_status = &port->port_dhc.auth_status;
9683 auth_time = port->port_dhc.auth_time;
9688 ndlp = emlxs_node_find_did(port, FABRIC_DID);
9684 ndlp = emlxs_node_find_did(port, FABRIC_DID, 1);
9689 } else {
9690 auth_status = &auth_cfg->auth_status;
9691 auth_time = auth_cfg->auth_time;
9692 ndlp = auth_cfg->node;
9693 }
9694
9695 update = 0;
9696

--- 40 unchanged lines hidden (view full) ---

9737 emlxs_config_t *cfg = &CFG;
9738 emlxs_auth_cfg_t *auth_cfg;
9739 uint32_t i;
9740
9741 /* Return if authentication is not enabled */
9742 if (cfg[CFG_AUTH_ENABLE].current == 0) {
9743 EMLXS_MSGF(EMLXS_CONTEXT,
9744 &emlxs_fcsp_debug_msg,
9685 } else {
9686 auth_status = &auth_cfg->auth_status;
9687 auth_time = auth_cfg->auth_time;
9688 ndlp = auth_cfg->node;
9689 }
9690
9691 update = 0;
9692

--- 40 unchanged lines hidden (view full) ---

9733 emlxs_config_t *cfg = &CFG;
9734 emlxs_auth_cfg_t *auth_cfg;
9735 uint32_t i;
9736
9737 /* Return if authentication is not enabled */
9738 if (cfg[CFG_AUTH_ENABLE].current == 0) {
9739 EMLXS_MSGF(EMLXS_CONTEXT,
9740 &emlxs_fcsp_debug_msg,
9745 "emlxs_dhc_get_auth_cfg_table. Auth disabled.");
9741 "dhc_get_auth_cfg_table. Auth disabled.");
9746
9747 return (DFC_AUTH_AUTHENTICATION_DISABLED);
9748 }
9749 for (auth_cfg = hba->auth_cfg.next;
9750 auth_cfg != &hba->auth_cfg;
9751 auth_cfg = auth_cfg->next) {
9752 bcopy((uint8_t *)&auth_cfg->local_entity,
9753 (uint8_t *)&fcsp_cfg->lwwpn, 8);

--- 36 unchanged lines hidden (view full) ---

9790 emlxs_port_t *port = &PPORT;
9791 emlxs_config_t *cfg = &CFG;
9792 emlxs_auth_key_t *auth_key;
9793
9794 /* Return if authentication is not enabled */
9795 if (cfg[CFG_AUTH_ENABLE].current == 0) {
9796 EMLXS_MSGF(EMLXS_CONTEXT,
9797 &emlxs_fcsp_debug_msg,
9742
9743 return (DFC_AUTH_AUTHENTICATION_DISABLED);
9744 }
9745 for (auth_cfg = hba->auth_cfg.next;
9746 auth_cfg != &hba->auth_cfg;
9747 auth_cfg = auth_cfg->next) {
9748 bcopy((uint8_t *)&auth_cfg->local_entity,
9749 (uint8_t *)&fcsp_cfg->lwwpn, 8);

--- 36 unchanged lines hidden (view full) ---

9786 emlxs_port_t *port = &PPORT;
9787 emlxs_config_t *cfg = &CFG;
9788 emlxs_auth_key_t *auth_key;
9789
9790 /* Return if authentication is not enabled */
9791 if (cfg[CFG_AUTH_ENABLE].current == 0) {
9792 EMLXS_MSGF(EMLXS_CONTEXT,
9793 &emlxs_fcsp_debug_msg,
9798 "emlxs_dhc_get_auth_key_table. Auth disabled.");
9794 "dhc_get_auth_key_table. Auth disabled.");
9799
9800 return (DFC_AUTH_AUTHENTICATION_DISABLED);
9801 }
9802 for (auth_key = hba->auth_key.next;
9803 auth_key != &hba->auth_key;
9804 auth_key = auth_key->next) {
9805 bcopy((uint8_t *)&auth_key->local_entity,
9806 (uint8_t *)&auth_pwd->lwwpn, 8);

--- 39 unchanged lines hidden --- 		9795
9796 return (DFC_AUTH_AUTHENTICATION_DISABLED);
9797 }
9798 for (auth_key = hba->auth_key.next;
9799 auth_key != &hba->auth_key;
9800 auth_key = auth_key->next) {
9801 bcopy((uint8_t *)&auth_key->local_entity,
9802 (uint8_t *)&auth_pwd->lwwpn, 8);

--- 39 unchanged lines hidden ---