#include "security.h"
#include "protocol.h"
-#define proto_debug(i,x) do { \
- if ((i) <= debug_protocol) { \
- dbprintf(x); \
- } \
+#define proto_debug(i, ...) do { \
+ if ((i) <= debug_protocol) { \
+ dbprintf(__VA_ARGS__); \
+ } \
} while (0)
/*
p->resettries = RESET_TRIES;
p->reqtries = getconf_int(CNF_REQ_TRIES);
p->conf_fn = conf_fn;
- pkt_init(&p->req, P_REQ, req);
+ pkt_init(&p->req, P_REQ, "%s", req);
/*
* These are here for the caller
p->continuation = continuation;
p->datap = datap;
- proto_debug(1, ("%s: security_connect: host %s -> p %p\n",
- debug_prefix_time(": protocol"), hostname, p));
+ proto_debug(1, _("protocol: security_connect: host %s -> p %p\n"),
+ hostname, p);
security_connect(p->security_driver, p->hostname, conf_fn, connect_callback,
p, p->datap);
assert(p != NULL);
p->security_handle = security_handle;
- proto_debug(1, ("%s: connect_callback: p %p\n",
- debug_prefix_time(": protocol"), p));
+ proto_debug(1, _("protocol: connect_callback: p %p\n"), p);
switch (status) {
case S_OK:
break;
case S_TIMEOUT:
- security_seterror(p->security_handle, "timeout during connect");
+ security_seterror(p->security_handle, _("timeout during connect"));
/* FALLTHROUGH */
case S_ERROR:
if (--p->connecttries == 0) {
state_machine(p, PA_ABORT, NULL);
} else {
- proto_debug(1, ("%s: connect_callback: p %p: retrying %s\n",
- debug_prefix_time(": protocol"), p, p->hostname));
+ proto_debug(1, _("protocol: connect_callback: p %p: retrying %s\n"),
+ p, p->hostname);
security_close(p->security_handle);
/* XXX overload p->security handle to hold the event handle */
p->security_handle =
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));
+ 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, ("%s: state_machine: p %p state %s action %s\n",
- debug_prefix_time(": protocol"),
- p, pstate2str(p->state), action2str(action)));
+ 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, ("%s: pkt: %s (t %d) orig REQ (t %d cur %d)\n",
- debug_prefix_time(": protocol"),
+ 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, ("%s: pkt contents:\n-----\n%s-----\n",
- debug_prefix_time(": protocol"), pkt->body));
+ (int)p->origtime, (int)p->curtime);
+ proto_debug(1, _("protocol: pkt contents:\n-----\n%s-----\n"),
+ pkt->body);
}
/*
*/
retaction = (*curstate)(p, action, pkt);
- proto_debug(1, ("%s: state_machine: p %p state %s returned %s\n",
- debug_prefix_time(": protocol"),
- p, pstate2str(p->state), action2str(retaction)));
+ 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
/* FALLTHROUGH */
case PA_PENDING:
- proto_debug(1, ("%s: state_machine: p %p state %s: timeout %d\n",
- debug_prefix_time(": protocol"),
- p, pstate2str(p->state), (int)p->timeout));
+ 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
*/
case PA_CONTINUE:
assert(p->state != curstate);
- proto_debug(1, ("%s: state_machine: p %p: moved from %s to %s\n",
- debug_prefix_time(": protocol"),
+ proto_debug(1, _("protocol: state_machine: p %p: moved from %s to %s\n"),
p, pstate2str(curstate),
- pstate2str(p->state)));
+ pstate2str(p->state));
continue;
/*
if (security_sendpkt(p->security_handle, &p->req) < 0) {
/* XXX should retry */
- security_seterror(p->security_handle, "error sending REQ: %s",
+ security_seterror(p->security_handle, _("error sending REQ: %s"),
security_geterror(p->security_handle));
return (PA_ABORT);
}
assert(pkt == NULL);
if (--p->reqtries == 0) {
- security_seterror(p->security_handle, "timeout waiting for ACK");
+ security_seterror(p->security_handle, _("timeout waiting for ACK"));
return (PA_ABORT);
}
* return.
*/
if (p->resettries == 0 || DROP_DEAD_TIME(p->origtime)) {
- security_seterror(p->security_handle, "timeout waiting for REP");
+ security_seterror(p->security_handle, _("timeout waiting for REP"));
return (PA_ABORT);
}
assert(action == PA_RCVDATA);
+ /* Finish if we get a NAK */
+ if (pkt->type == P_NAK)
+ return (PA_FINISH);
+
/*
* We've received some data. If we didn't get a reply,
* requeue the packet and retry. Otherwise, acknowledge
if (security_sendpkt(p->security_handle, &ack) < 0) {
/* XXX should retry */
amfree(ack.body);
- security_seterror(p->security_handle, "error sending ACK: %s",
+ security_seterror(p->security_handle, _("error sending ACK: %s"),
security_geterror(p->security_handle));
return (PA_ABORT);
}
}
else if(pkt->type == P_PREP) {
p->timeout = p->repwait - CURTIME + p->curtime + 1;
+ if (p->timeout <= 0)
+ p->timeout = 1;
return (PA_CONTPEND);
}
for (i = 0; i < ASIZE(pstates); i++)
if (pstate == pstates[i].type)
return (pstates[i].name);
- return ("BOGUS PSTATE");
+ return (_("BOGUS PSTATE"));
}
/*
for (i = 0; i < ASIZE(actions); i++)
if (action == actions[i].type)
return (actions[i].name);
- return ("BOGUS ACTION");
+ return (_("BOGUS ACTION"));
}