static void sll_print_full(struct pkt_buff *pkt)
{
struct sockaddr_ll *sll = pkt->sll;
char addr_str[40] = {};
tprintf(" [ Linux \"cooked\"");
tprintf(" Pkt Type %d (%s)", sll->sll_pkttype,
pkt_type2str(sll->sll_pkttype));
tprintf(", If Type %d (%s)", sll->sll_hatype,
device_type2str(sll->sll_hatype));
tprintf(", Addr Len %d", sll->sll_halen);
tprintf(", Src (%s)", device_addr2str(sll->sll_addr, sll->sll_halen,
sll->sll_hatype, addr_str, sizeof(addr_str)));
tprintf(", Proto 0x%x", ntohs(sll->sll_protocol));
tprintf(" ]\n");
switch (pcap_devtype_to_linktype(sll->sll_hatype)) {
case LINKTYPE_EN10MB:
case ___constant_swab32(LINKTYPE_EN10MB):
pkt_set_dissector(pkt, ð_lay2, ntohs(sll->sll_protocol));
break;
case LINKTYPE_NETLINK:
case ___constant_swab32(LINKTYPE_NETLINK):
pkt->dissector = &nlmsg_ops;
break;
default:
tprintf(" [ Unknown protocol ]\n");
}
}
static void sll_print_less(struct pkt_buff *pkt)
{
struct sockaddr_ll *sll = pkt->sll;
char addr_str[40] = {};
tprintf(" Pkt Type %d (%s)", sll->sll_pkttype,
pkt_type2str(sll->sll_pkttype));
tprintf(", If Type %d (%s)", sll->sll_hatype,
device_type2str(sll->sll_hatype));
tprintf(", Addr Len %d", sll->sll_halen);
tprintf(", Src (%s)", device_addr2str(sll->sll_addr, sll->sll_halen,
sll->sll_hatype, addr_str, sizeof(addr_str)));
tprintf(", Proto 0x%x", ntohs(sll->sll_protocol));
}
void uct_ud_log_packet(const char *file, int line, const char *function,
uct_ud_iface_t *iface, uct_ud_ep_t *ep,
uct_am_trace_type_t type, uct_ud_neth_t *neth, uint32_t len)
{
char buf[256] = {0};
char *p;
int n, max;
p = buf;
max = sizeof(buf);
n = snprintf(p, max, "%s: if=%p ",
pkt_type2str(type), iface);
p += n; max -= n;
n = uct_ud_dump_ep(p, max, ep);
p += n; max -= n;
uct_ud_dump_neth(iface, type, p, max, neth, len);
uct_log_data(file, line, function, buf);
}
/*
* The guts of the protocol. This handles the many paths a request can
* make, including retrying the request and acknowledgements, and dealing
* with timeouts and successfull replies.
*/
static void
state_machine(
proto_t * p,
p_action_t action,
pkt_t * pkt)
{
pstate_t curstate;
p_action_t retaction;
proto_debug(1, _("protocol: state_machine: initial: p %p action %s pkt %p\n"),
p, action2str(action), (void *)NULL);
assert(p != NULL);
assert(action == PA_RCVDATA || pkt == NULL);
assert(p->state != NULL);
for (;;) {
proto_debug(1, _("protocol: state_machine: p %p state %s action %s\n"),
p, pstate2str(p->state), action2str(action));
if (pkt != NULL) {
proto_debug(1, _("protocol: pkt: %s (t %d) orig REQ (t %d cur %d)\n"),
pkt_type2str(pkt->type), (int)CURTIME,
(int)p->origtime, (int)p->curtime);
proto_debug(1, _("protocol: pkt contents:\n-----\n%s-----\n"),
pkt->body);
}
/*
* p->state is a function pointer to the current state a request
* is in.
*
* We keep track of the last state we were in so we can make
* sure states which return PA_CONTINUE really have transitioned
* the request to a new state.
*/
curstate = p->state;
if (action == PA_ABORT)
/*
* If the passed action indicates a terminal error, then we
* need to move to abort right away.
*/
retaction = PA_ABORT;
else
/*
* Else we run the state and perform the action it
* requests.
*/
retaction = (*curstate)(p, action, pkt);
proto_debug(1, _("protocol: state_machine: p %p state %s returned %s\n"),
p, pstate2str(p->state), action2str(retaction));
/*
* The state function is expected to return one of the following
* p_action_t's.
*/
switch (retaction) {
/*
* Request is still waiting for more data off of the network.
* Setup to receive another pkt, and wait for the recv event
* to occur.
*/
case PA_CONTPEND:
(*p->continuation)(p->datap, pkt, p->security_handle);
/* FALLTHROUGH */
case PA_PENDING:
proto_debug(1, _("protocol: state_machine: p %p state %s: timeout %d\n"),
p, pstate2str(p->state), (int)p->timeout);
/*
* Get the security layer to register a receive event for this
* security handle on our behalf. Have it timeout in p->timeout
* seconds.
*/
security_recvpkt(p->security_handle, recvpkt_callback, p,
(int)p->timeout);
return;
/*
* Request has moved to another state. Loop and run it again.
*/
case PA_CONTINUE:
assert(p->state != curstate);
proto_debug(1, _("protocol: state_machine: p %p: moved from %s to %s\n"),
p, pstate2str(curstate),
pstate2str(p->state));
continue;
/*
* Request has failed in some way locally. The security_handle will
* contain an appropriate error message via security_geterror(). Set
* pkt to NULL to indicate failure to the callback, and then
* fall through to the common finish code.
*
* Note that remote failures finish via PA_FINISH, because they did
* complete successfully locally.
*/
case PA_ABORT:
pkt = NULL;
/* FALLTHROUGH */
/*
* Request has completed successfully.
* Free up resources the request has used, call the continuation
* function specified by the caller and quit.
*/
case PA_FINISH:
(*p->continuation)(p->datap, pkt, p->security_handle);
security_close(p->security_handle);
amfree(p->hostname);
amfree(p->req.body);
amfree(p);
return;
default:
assert(0);
break; /* in case asserts are turned off */
}
/*NOTREACHED*/
}
/*NOTREACHED*/
}
static void
amindexd_response(
void *datap,
pkt_t *pkt,
security_handle_t *sech)
{
int ports[NSTREAMS], *response_error = datap;
guint i;
char *p;
char *tok;
char *extra = NULL;
assert(response_error != NULL);
assert(sech != NULL);
if (pkt == NULL) {
errstr = newvstrallocf(errstr, _("[request failed: %s]"),
security_geterror(sech));
*response_error = 1;
return;
}
if (pkt->type == P_NAK) {
#if defined(PACKET_DEBUG)
dbprintf(_("got nak response:\n----\n%s\n----\n\n"), pkt->body);
#endif
tok = strtok(pkt->body, " ");
if (tok == NULL || strcmp(tok, "ERROR") != 0)
goto bad_nak;
tok = strtok(NULL, "\n");
if (tok != NULL) {
errstr = newvstrallocf(errstr, "NAK: %s", tok);
*response_error = 1;
} else {
bad_nak:
errstr = newvstrallocf(errstr, _("request NAK"));
*response_error = 2;
}
return;
}
if (pkt->type != P_REP) {
errstr = newvstrallocf(errstr, _("received strange packet type %s: %s"),
pkt_type2str(pkt->type), pkt->body);
*response_error = 1;
return;
}
#if defined(PACKET_DEBUG)
g_fprintf(stderr, _("got response:\n----\n%s\n----\n\n"), pkt->body);
#endif
for(i = 0; i < NSTREAMS; i++) {
ports[i] = -1;
streams[i].fd = NULL;
}
p = pkt->body;
while((tok = strtok(p, " \n")) != NULL) {
p = NULL;
/*
* Error response packets have "ERROR" followed by the error message
* followed by a newline.
*/
if (strcmp(tok, "ERROR") == 0) {
tok = strtok(NULL, "\n");
if (tok == NULL) {
errstr = newvstrallocf(errstr, _("[bogus error packet]"));
} else {
errstr = newvstrallocf(errstr, "%s", tok);
}
*response_error = 2;
return;
}
/*
* Regular packets have CONNECT followed by three streams
*/
if (strcmp(tok, "CONNECT") == 0) {
/*
* Parse the three stream specifiers out of the packet.
*/
for (i = 0; i < NSTREAMS; i++) {
tok = strtok(NULL, " ");
if (tok == NULL || strcmp(tok, streams[i].name) != 0) {
extra = g_strdup_printf(
_("CONNECT token is \"%s\": expected \"%s\""),
tok ? tok : _("(null)"), streams[i].name);
goto parse_error;
}
tok = strtok(NULL, " \n");
if (tok == NULL || sscanf(tok, "%d", &ports[i]) != 1) {
extra = g_strdup_printf(
_("CONNECT %s token is \"%s\" expected a port number"),
streams[i].name, tok ? tok : _("(null)"));
goto parse_error;
}
}
continue;
}
/*
* OPTIONS [options string] '\n'
*/
if (strcmp(tok, "OPTIONS") == 0) {
tok = strtok(NULL, "\n");
if (tok == NULL) {
extra = g_strdup(_("OPTIONS token is missing"));
goto parse_error;
}
#if 0
tok_end = tok + strlen(tok);
while((p = strchr(tok, ';')) != NULL) {
*p++ = '\0';
if(strncmp_const(tok, "features=") == 0) {
tok += sizeof("features=") - 1;
am_release_feature_set(their_features);
if((their_features = am_string_to_feature(tok)) == NULL) {
errstr = newvstrallocf(errstr,
_("OPTIONS: bad features value: %s"),
tok);
goto parse_error;
}
}
tok = p;
}
#endif
continue;
}
#if 0
extra = g_strdup_printf(_("next token is \"%s\": expected \"CONNECT\", \"ERROR\" or \"OPTIONS\""), tok ? tok : _("(null)"));
goto parse_error;
#endif
}
/*
* Connect the streams to their remote ports
*/
for (i = 0; i < NSTREAMS; i++) {
/*@i@*/ if (ports[i] == -1)
continue;
streams[i].fd = security_stream_client(sech, ports[i]);
if (streams[i].fd == NULL) {
errstr = newvstrallocf(errstr,
_("[could not connect %s stream: %s]"),
streams[i].name, security_geterror(sech));
goto connect_error;
}
}
/*
* Authenticate the streams
*/
for (i = 0; i < NSTREAMS; i++) {
if (streams[i].fd == NULL)
continue;
if (security_stream_auth(streams[i].fd) < 0) {
errstr = newvstrallocf(errstr,
_("[could not authenticate %s stream: %s]"),
streams[i].name, security_stream_geterror(streams[i].fd));
goto connect_error;
}
}
/*
* The MESGFD and DATAFD streams are mandatory. If we didn't get
* them, complain.
*/
if (streams[MESGFD].fd == NULL) {
errstr = newvstrallocf(errstr, _("[couldn't open MESG streams]"));
goto connect_error;
}
/* everything worked */
*response_error = 0;
amindexd_alive = 1;
return;
parse_error:
errstr = newvstrallocf(errstr,
_("[parse of reply message failed: %s]"),
extra ? extra : _("(no additional information)"));
amfree(extra);
*response_error = 2;
return;
connect_error:
stop_amindexd();
*response_error = 1;
}
