//Begin ClientCode
int main(int argc, char ** argv)
{
#ifdef CSEC_VERIFY
assume_string("clientID");
assume_string("serverID");
assume_string("port_ascii");
// Assumption that the corresponding argv fields indeed contains the correct ids:
readenvL(argv[1], strlen(argv[1]), "clientID");
readenvL(argv[2], strlen(argv[2]), "serverID");
readenvL(argv[3], strlen(argv[3]), "port_ascii");
#endif
RPCstate clState;
clState.end = CLIENT;
if (parseargs(argc,argv,&clState))
{
#ifdef VERBOSE
fprintf(stdout, "Usage: client clientAddress serverAddress [port] request\n");
#endif
exit(-1);
}
#ifdef VERBOSE
printf("Client: Now connecting to ");
print_text_buffer(clState.other,clState.other_len);
printf(", port %d.\n", clState.port);
fflush(stdout);
#endif
// Getting arguments
if (socket_connect(&(clState.conn_fd),(char*) clState.other, clState.other_len, clState.port))
return -1;
clState.k_ab = get_shared_key(clState.self, clState.self_len, clState.other, clState.other_len, &(clState.k_ab_len));
clState.k = mk_session_key(&(clState.k_len));
clState.response = NULL;
#ifdef CSEC_VERIFY
event3("client_begin", clState.self, clState.self_len, clState.other, clState.other_len, clState.request, clState.request_len);
#endif
/* Send request */
if (send_request(&clState) < 0) return -1;
/* Receive response */
if (recv_response(&clState) < 0) return -1;
#ifdef CSEC_VERIFY
event4("client_accept", clState.self, clState.self_len, clState.other, clState.other_len,
clState.request, clState.request_len, clState.response, clState.response_len);
#endif
return 0;
}
int recv_response(RPCstate * ctx)
{
unsigned char * m2_e;
uint32_t m2_e_len;
recv(&(ctx->conn_fd), (unsigned char*) &m2_e_len, sizeof(m2_e_len));
// Check if the read length is within bounds
if (m2_e_len < MIN_MSG2_LENGTH || m2_e_len > MAX_MSG2_LENGTH)
fail("client: msg2 has wrong length: %d", m2_e_len);
m2_e = malloc(m2_e_len);
if (m2_e == NULL)
return -1;
recv(&(ctx->conn_fd), m2_e, m2_e_len);
#ifdef VERBOSE
printf("Client: Received encrypted message: ");
print_buffer(m2_e,m2_e_len);
fflush(stdout);
#endif
ctx->response_len = decrypt_len(ctx->k, ctx->k_len, m2_e, m2_e_len);
if (ctx->response_len > MAX_PAYLOAD_LENGTH)
{
free(m2_e);
return -1;
}
ctx->response = malloc(ctx->response_len);
if (ctx->response == NULL)
{
free(m2_e);
return -1;
}
// this call returns 0 if not encrypted with the right key
ctx->response_len = decrypt(ctx->k, ctx->k_len, m2_e, m2_e_len, ctx->response);
if (ctx->response_len == 0)
{
free(m2_e);
return -1;
}
if(ctx->response_len < MIN_PAYLOAD_LENGTH || ctx->response_len > MAX_PAYLOAD_LENGTH)
fail("Client: response too long: %d", ctx->response_len);
#ifdef VERBOSE
printf("Client: Received and authenticated response: ");
print_text_buffer(ctx->response,ctx->response_len);
printf("\n");
fflush(stdout);
#endif
return 0;
}
void show_inv_field(SaHpiIdrFieldT *Field, int del, hpi_ui_print_cb_t proc)
{
char buf[SHOW_BUF_SZ], *str;
int len;
del <<= 1;
len = SHOW_BUF_SZ - del;
str = buf + del;
memset(buf, ' ', SHOW_BUF_SZ);
snprintf(str, len, "Field Id: %d\n", Field->FieldId);
if (proc(buf) != 0) return;
snprintf(str, len, "Field Type: %s\n", oh_lookup_idrfieldtype(Field->Type));
if (proc(buf) != 0) return;
snprintf(str, len, "ReadOnly: %s\n", HPIBOOL2STR( Field->ReadOnly ));
if (proc(buf) != 0) return;
*str = 0;
proc(buf);
print_text_buffer("Content: ", &(Field->Field), "\n", proc);
}
SaErrorT show_inventory(SaHpiSessionIdT sessionid, SaHpiResourceIdT resourceid,
SaHpiIdrIdT IdrId, hpi_ui_print_cb_t proc)
{
SaHpiIdrInfoT info;
SaErrorT rv;
SaHpiEntryIdT entryid, nextentryid;
SaHpiEntryIdT fentryid, nextfentryid;
SaHpiIdrAreaHeaderT hdr;
SaHpiIdrFieldT field;
char buf[SHOW_BUF_SZ];
char *str;
int num;
rv = saHpiIdrInfoGet(sessionid, resourceid, IdrId, &info);
if (rv != SA_OK) {
snprintf(buf, SHOW_BUF_SZ, "ERROR!!! saHpiIdrInfoGet: %s\n",
oh_lookup_error(rv));
proc(buf);
return(-1);
};
num = info.NumAreas;
snprintf(buf, SHOW_BUF_SZ,
"Inventory: %d Update count: %d Read only: %d Areas: %d\n",
info.IdrId, info.UpdateCount, info.ReadOnly, num);
if (proc(buf) != 0) return(SA_OK);
entryid = SAHPI_FIRST_ENTRY;
while ((entryid != SAHPI_LAST_ENTRY) && (num > 0)) {
rv = saHpiIdrAreaHeaderGet(sessionid, resourceid, IdrId,
SAHPI_IDR_AREATYPE_UNSPECIFIED, entryid,
&nextentryid, &hdr);
if (rv != SA_OK) {
proc("ERROR!!! saHpiIdrAreaHeaderGet\n");
return(-1);
};
str = oh_lookup_idrareatype(hdr.Type);
if (str == NULL) str = "Unknown";
snprintf(buf, SHOW_BUF_SZ,
" Area: %d Type: %s Read Only: %d Fields: %d\n",
hdr.AreaId, str, hdr.ReadOnly, hdr.NumFields);
if (proc(buf) != 0) return(SA_OK);
fentryid = SAHPI_FIRST_ENTRY;
entryid = nextentryid;
while ((fentryid != SAHPI_LAST_ENTRY) && (hdr.NumFields > 0)) {
rv = saHpiIdrFieldGet(sessionid, resourceid, IdrId, hdr.AreaId,
SAHPI_IDR_FIELDTYPE_UNSPECIFIED, fentryid,
&nextfentryid, &field);
if (rv != SA_OK) {
proc("ERROR!!! saHpiIdrFieldGet\n");
return(-1);
};
str = oh_lookup_idrfieldtype(field.Type);
if (str == NULL) str = "Unknown";
snprintf(buf, SHOW_BUF_SZ,
" Field: %d Type: %s Read Only: %d (",
field.FieldId, str, field.ReadOnly);
if (proc(buf) != 0) return(SA_OK);
if (print_text_buffer(NULL, &(field.Field), NULL, proc) != 0)
return(SA_OK);
if (proc(")\n") != 0) return(SA_OK);
fentryid = nextfentryid;
}
};
return(SA_OK);
}
static Pr_ret_t show_attrs(Attributes_t *Attrs, int delta, hpi_ui_print_cb_t proc)
{
int i, type, len, del;
char tmp[256], *name;
char buf[SHOW_BUF_SZ];
union_type_t val;
SaErrorT rv;
Pr_ret_t ret;
memset(buf, ' ', SHOW_BUF_SZ);
del = delta << 1;
len = SHOW_BUF_SZ - del;
for (i = 0; i < Attrs->n_attrs; i++) {
name = get_attr_name(Attrs, i);
if (name == (char *)NULL)
break;
rv = get_value(Attrs, i, &val);
if (rv != SA_OK) continue;
type = get_attr_type(Attrs, i);
switch (type) {
case NO_TYPE: continue;
case STRUCT_TYPE:
snprintf(buf + del, len, "%s:\n", name);
if (proc(buf) != 0) return(-1);
rv = get_value(Attrs, i, &val);
if (rv != SA_OK) continue;
ret = show_attrs((Attributes_t *)(val.a),
delta + 1, proc);
if (ret != HPI_UI_OK) return(HPI_UI_END);
continue;
case LOOKUP_TYPE:
strncpy(tmp, lookup_proc(Attrs->Attrs[i].lunum,
val.i), 256);
break;
case DECODE_TYPE:
rv = decode_proc(Attrs->Attrs[i].lunum, val.a,
tmp, 256);
if (rv != SA_OK) continue;
break;
case DECODE1_TYPE:
rv = decode1_proc(Attrs->Attrs[i].lunum, val.i,
tmp, 256);
if (rv != SA_OK) continue;
break;
case READING_TYPE:
if (thres_value(val.a, tmp, 256) != SA_OK)
continue;
break;
case TEXT_BUFF_TYPE:
snprintf(buf + del, len, "%s: ", name);
if (proc(buf) != HPI_UI_OK) return(HPI_UI_END);
ret = print_text_buffer(NULL, val.a, "\n", proc);
if (ret != HPI_UI_OK) return(HPI_UI_END);
continue;
default:
rv = get_value_as_string(Attrs, i, tmp, 256);
if (rv != SA_OK) continue;
};
snprintf(buf + del, len, "%s: %s\n", name, tmp);
if (proc(buf) != HPI_UI_OK) return(HPI_UI_END);
};
return(0);
}
int send_request(RPCstate * ctx)
{
uint32_t m1_len, m1_e_len, full_len;
unsigned char * m1, * p, * m1_e;
#ifdef VERBOSE
printf("Client: Preparing to send request: ");
print_text_buffer(ctx->request,ctx->request_len);
printf("\nand session key: ");
print_buffer(ctx->k,ctx->k_len);
fflush(stdout);
#endif
m1_len = 1 + ctx->k_len + sizeof(ctx->request_len) + ctx->request_len;
p = m1 = malloc(m1_len);
if (m1 == NULL) return -1;
memcpy(p, "p", 1);
p += 1;
*((uint32_t *) p) = ctx->request_len;
p += sizeof(ctx->request_len);
memcpy(p, ctx->request, ctx->request_len);
p += ctx->request_len;
memcpy(p, ctx->k, ctx->k_len);
full_len = 1 + sizeof(ctx->self_len) + ctx->self_len + encrypt_len(ctx->k_ab, ctx->k_ab_len, m1, m1_len);
p = m1_e = malloc(full_len);
if (m1_e == NULL)
{
free(m1);
return -1;
}
memcpy(p, "p", 1);
p += 1;
*((uint32_t *) p) = ctx->self_len;
p += sizeof(ctx->self_len);
memcpy(p, ctx->self, ctx->self_len);
p += ctx->self_len;
m1_e_len = encrypt(ctx->k_ab, ctx->k_ab_len, m1, m1_len, p);
if (m1_e_len == 0)
{
free(m1);
return -1;
}
full_len = 1 + sizeof(ctx->self_len) + ctx->self_len + m1_e_len;
#ifdef VERBOSE
printf("Client: Sending message: %.1s | %u | ", m1_e, *((uint32_t*) (m1_e + 1)));
print_text_buffer(m1_e + 1 + sizeof(uint32_t),ctx->self_len);
printf(" | ");
print_buffer(p,m1_e_len);
fflush(stdout);
#endif
send(&(ctx->conn_fd), (unsigned char *) &full_len, sizeof(full_len));
send(&(ctx->conn_fd), m1_e, full_len);
free(m1);
free(m1_e);
return 0;
}
