ucp.c

使用Modem发送网上传呼

	MCHK (u);
	if (u) {
		if (u -> uline) {
			free (u -> uline);
			u -> uline = NULL;
		}
		if (str = sextract (s)) {
			if (u -> uline = malloc (strlen (str) + 4))
				sprintf (u -> uline, "%s%c", str, (char) sep);
			free (str);
		}
	}
}
/*}}}*/
/*{{{	interpret originate message */
static void
interpret_originate (ucp *u, frame *f)
{
	string_t	*msg;
	
	msg = NULL;
	switch (f -> ot) {
	case 1:
	case 31:
		msg = f -> b.s.msg;
		break;
	case 51:
	case 52:
	case 53:
	case 55:
	case 56:
	case 57:
	case 58:
		msg = f -> b.e.msg;
		break;
	}
	if (msg)
		V (1, ("Got message type %d: `%s'\n", f -> ot, schar (msg)));
}
/*}}}*/
/*{{{	send a message */
static Bool
send_msg (ucp *u, string_t *msg, Bool wds, int *err)
{
	Bool		ret;
	Bool		dosend;
	int		n;
	int		ep;
	frame		*f, *ans;
	banswer		*an;
	string_t	*astr;
	char		*ptr;

	ret = False;
	dosend = True;
	for (n = 0; n < 2; ++n) {
		if ((! n) && dosend) {
			dosend = False;
			if (tty_send (u -> sp, msg -> str, msg -> len) != msg -> len) {
				V (1, ("Unable to send message\n"));
				*err = ERR_FAIL;
				break;
			}
		}
		if (n && (! wds))
			continue;
		ep = tty_expect (u -> sp, (n ? u -> rds_tout : u -> send_tout), "\x03", 1, NULL);
		if ((ep != 1) || (! u -> uline)) {
			if (ep < 0)
				*err = ERR_FAIL;
			break;
		}
		if (f = parse_frame (u, u -> uline)) {
			switch (f -> ttyp) {
			case 'R':
				if (f -> b.a.ack) {
					V (1, ("Message spooled\n"));
					ret = True;
					break;
				} else {
					switch (f -> b.a.ec) {
					default:
						ptr = "unknown error";
						break;
					case 1:
						ptr = "checksum error";
						break;
					case 2:
						ptr = "syntax error";
						break;
					case 3:
						ptr = "operation not supported by system";
						break;
					case 4:
						ptr = "operation not allowed (at this point)";
						break;
					case 5:
						ptr = "call barring active";
						break;
					case 6:
						ptr = "AdC invalid";
						break;
					case 7:
						ptr = "authentication failure";
						break;
					case 8:
						ptr = "legitimisation code for all calls, failure";
						break;
					case 9:
						ptr = "GA not valid";
						break;
					case 10:
						ptr = "repetition not allowed";
						break;
					case 11:
						ptr = "legitimisation code for repetition, failure";
						break;
					case 12:
						ptr = "priority call not allowed";
						break;
					case 13:
						ptr = "legitimisation code for priority, failure";
						break;
					case 14:
						ptr = "urgent message not allowed";
						break;
					case 15:
						ptr = "legitimisation code for urgent message, failure";
						break;
					case 16:
						ptr = "reveerse charging not allowed";
						break;
					case 17:
						ptr = "legitimisation code for reverse charging, failure";
						break;
					case 18:
						ptr = "deferred delivery not allowed";
						break;
					case 19:
						ptr = "new AC not valid";
						break;
					case 20:
						ptr = "new legitimisation code not valid";
						break;
					case 21:
						ptr = "standard text not valid";
						break;
					case 22:
						ptr = "time period not valid";
						break;
					case 23:
						ptr = "message type not supported by system";
						break;
					case 24:
						ptr = "message too long";
						break;
					case 25:
						ptr = "requested standard text not valid";
						break;
					case 26:
						ptr = "message type not valid for pager type";
						break;
					case 27:
						ptr = "message not found in SMSC";
						break;
					case 30:
						ptr = "subscriber hang-up";
						break;
					case 31:
						ptr = "fax group not supported";
						break;
					case 32:
						ptr = "fax message type not supported";
						break;
					case 33:
						ptr = "address already in list (60 series)";
						break;
					case 34:
						ptr = "address not in list (60 series)";
						break;
					case 35:
						ptr = "list full (60 series)";
						break;
					}
					V (1, ("Invalid message (error %d) %s\n", f -> b.a.ec, (ptr ? ptr : "")));
					switch (f -> b.a.ec) {
					case -1:
					case 1:		case 2:		case 3:
					case 6:		case 7:		case 8:
					case 9:		case 10:	case 11:
					case 12:	case 13:	case 14:
					case 15:	case 16:	case 17:
					case 18:	case 19:	case 20:
					case 21:	case 22:	case 23:
					case 24:	case 25:	case 26:
					case 27:	case 31:	case 32:
					case 33:	case 34:	case 35:
						*err = ERR_FAIL;
						break;
					default:
						*err = ERR_FATAL;
						break;
					}
				}
				break;
			case 'O':
				if (n && wds && (f -> ot == 53)) {
					if (u -> logger) {
						switch (f -> b.e.dst) {
						default:	ptr = NULL;	break;
						case 0:	ptr = "delivered";	break;
						case 1:	ptr = "buffered";	break;
						}
						if (ptr)
							(*u -> logger) (LG_PROTO, "UCP: message %s", ptr);
					}
					printf ("Message ");
					switch (f -> b.e.dst) {
					case 0:	printf ("delivered");		break;
					case 1:	printf ("buffered");		break;
					case 2:	printf ("not delivered");	break;
					default:
						printf ("failed");
						break;
					}
					printf (" (%d)", f -> b.e.rsn);
					switch (f -> b.e.rsn) {
					default:
						ptr = "unknown error";
						break;
					case 0x01:	
						ptr = "successful delivered";
						break;
					case 0x02: case 0x03: case 0x04:
					case 0x05: case 0x06: case 0x07:
						ptr = "temporary no service";
						break;
					case 0x09:
						ptr = "unknown service";
						break;
					case 0x0a:
						ptr = "network timeout";
						break;
					case 0x32:
						ptr = "storing time expired";
						break;
					case 0x64:
						ptr = "service not supported";
						break;
					case 0x65:
						ptr = "receiver unknown";
						break;
					case 0x66:
						ptr = "service not available";
						break;
					case 0x67:
						ptr = "call locked";
						break;
					case 0x68:
						ptr = "operation locked";
						break;
					case 0x69:
						ptr = "service center overrun";
						break;
					case 0x6a:
						ptr = "service not supported";
						break;
					case 0x6b:
						ptr = "receiver temporary not reachable";
						break;
					case 0x6c:
						ptr = "delivering error";
						break;
					case 0x6d:
						ptr = "receiver run out of memory";
						break;
					case 0x6e:
						ptr = "protocol error";
						break;
					case 0x6f:
						ptr = "receiver does not support service";
						break;
					case 0x70:
						ptr = "unknown serice center";
						break;
					case 0x71:
						ptr = "service center overrun";
						break;
					case 0x72:
						ptr = "illegal receiving device";
						break;
					case 0x73:
						ptr = "receiver no customer";
						break;
					case 0x74:
						ptr = "error in receiving device";
						break;
					case 0x75:
						ptr = "lower protocol not available";
						break;
					case 0x76:
						ptr = "system error";
						break;
					case 0x77:
						ptr = "PLMN system error";
						break;
					case 0x78:
						ptr = "HLR system error";
						break;
					case 0x79:
						ptr = "VLR system error";
						break;
					case 0x7a:
						ptr = "previous VLR system error";
						break;
					case 0x7b:
						ptr = "error on delivering (check receiver ID)";
						break;
					case 0x7c:
						ptr = "VMSC system error";
						break;
					case 0x7d:
						ptr = "EIR system error";
						break;
					case 0x7e:
						ptr = "system error";
						break;
					case 0x7f:
						ptr = "unexpected data";
						break;
					case 0xc8:
						ptr = "addressing error for service center";
						break;
					case 0xc9:
						ptr = "invalid absolute storing time";
						break;
					case 0xca:
						ptr = "message too large";
						break;
					case 0xcb:
						ptr = "GDM message cannot be extracted";
						break;
					case 0xcc:
						ptr = "translation into IA5 not possible";
						break;
					case 0xcd:
						ptr = "invalid format of storing time";
						break;
					case 0xce:
						ptr = "invalid receiver address";
						break;
					case 0xcf:
						ptr = "message sent twice";
						break;
					case 0xd0:
						ptr = "invalid message type";
						break;
					}
					if (ptr)
						printf (" reason is %s", ptr);
					if (f -> b.e.msg)
						printf (": %s", schar (f -> b.e.msg));
					printf ("\n");
				} else {
					if (! n)
						--n;
					interpret_originate (u, f);
				}
				if (ans = new_frame ('R', f -> ot)) {
					ans -> trn = f -> trn;
					an = & ans -> b.a;
					an -> adc = u -> callid ? sextract (u -> callid) : NULL;
					dat_localtime (& an -> scts);
					switch (f -> ot) {
					case 1:
						an -> ack = False;
						an -> ec = 23;
						break;
					case 31:
						an -> ack = True;
						dosend = True;
						break;
					case 51:
						an -> ack = False;
						an -> ec = 23;
						break;
					case 52:
						an -> ack = True;
						break;
					case 53:
						an -> ack = True;
						break;
					case 55:
						an -> ack = False;
						an -> ec = 23;
						break;
					case 56:
						an -> ack = False;
						an -> ec = 23;
						break;
					case 57:
						an -> ack = True;
						break;
					case 58:
						an -> ack = True;
						break;
					}
					if (astr = assemble_frame (u, ans)) {
						if (tty_send (u -> sp, astr -> str, astr -> len) != astr -> len) {
							V (1, ("Unable to send answer\n"));
							*err = ERR_FAIL;
						}
						sfree (astr);
					}
					free_frame (ans);
				}
				break;
			}
			free_frame (f);
			if (*err != NO_ERR)
				break;
		}
	}
	return ret;
}
/*}}}*/
/*{{{	login/logout/transmit */
int
ucp_login (void *up, string_t *callid)
{
	ucp	*u = (ucp *) up;

	MCHK (u);
	if ((! u) || (! u -> sp))
		return ERR_ABORT;
	u -> cnr = 0;
	u -> callid = sfree (u -> callid);
	if (callid && (! (u -> callid = snew (callid -> str, callid -> len))))
		return ERR_ABORT;
	return NO_ERR;
}

int
ucp_logout (void *up)
{
	MCHK ((ucp *) up);
	return NO_ERR;
}

int
ucp_transmit (void *up, string_t *pagerid, string_t *msg, Bool last)
{
	ucp		*u = (ucp *) up;
	int		n, err;
	Bool		done;
	string_t	*smsg;
	
	MCHK (u);
	if ((! u) || (! u -> sp))
		return ERR_FATAL;
	err = NO_ERR;
	tty_set_line_callback (u -> sp, grabline, "\x03", (void *) u);
	for (n = 0; n < u -> send_retry; ++n)
		if (smsg = convert_ucp (u, last, pagerid, msg)) {
			done = send_msg (u, smsg, (u -> delay.day > 0 ? False : u -> rds), & err);
			sfree (smsg);
			if (done || (err != NO_ERR))
				break;
		}
	if ((n == u -> send_retry) || (err != NO_ERR)) {
		if (err == NO_ERR)
			err = ERR_FAIL;
		V (1, ("Unable to send message\n"));
	}
	tty_set_line_callback (u -> sp, NULL, NULL, NULL);
	if (u -> uline) {
		free (u -> uline);
		u -> uline = NULL;
	}
	return err;
}
/*}}}*/
/*{{{	configuration */
void
ucp_config (void *up, void (*logger) (char, char *, ...),
	    Bool xtend, int stout, int retry, int rtout,
	    date_t *delay, date_t *expire, Bool rds)
{
	ucp	*u = (ucp *) up;
	
	MCHK (u);
	if (u) {
		u -> logger = logger;
		u -> xtend = xtend;
		if (u -> xtend)
			u -> rds = rds;
		else {
			u -> rds = False;
			dat_clear (& u -> delay);
			dat_clear (& u -> expire);
		}
		if (stout >= 0)
			u -> send_tout = stout;
		if (retry >= 0)
			u -> send_retry = retry;
		if (rtout >= 0)
			u -> rds_tout = rtout;
		if (u -> xtend) {
			if (delay)
				u -> delay = *delay;
			if (expire)
				u -> expire = *expire;
		}
	}
}

void
ucp_set_convtable (void *up, void *ctab)
{
	ucp	*u = (ucp *) up;
	
	MCHK (u);
	if (u) {
		if (u -> ctab)
			cv_free (u -> ctab);
		u -> ctab = ctab;
	}
}

void
ucp_add_convtable (void *up, void *ctab)
{
	ucp	*u = (ucp *) up;
	
	MCHK (u);
	if (u) {
		if (! u -> ctab)
			u -> ctab = cv_new ();
		if (u -> ctab)
			cv_merge (u -> ctab, ctab, True);
	}
}
/*}}}*/
/*{{{	new/free/etc */
void *
ucp_new (void *sp)
{
	ucp	*u;
	
	if (u = (ucp *) malloc (sizeof (ucp))) {
# ifndef	NDEBUG
		u -> magic = MAGIC;
# endif		/* NDEBUG */
		u -> sp = sp;
		u -> ctab = NULL;
		u -> logger = NULL;
		u -> uline = NULL;
		u -> callid = NULL;
		u -> xtend = False;
		u -> send_tout = 60;
		u -> send_retry = 3;
		u -> rds_tout = 40;
		dat_clear (& u -> delay);
		dat_clear (& u -> expire);
		u -> rds = False;
		u -> cnr = 0;
	}
	return (void *) u;
}

void *
ucp_free (void *up)
{
	ucp	*u = (ucp *) up;
	
	MCHK (u);
	if (u) {
		if (u -> ctab)
			cv_free (u -> ctab);
		if (u -> uline)
			free (u -> uline);
		if (u -> callid)
			sfree (u -> callid);
		free (u);
	}
	return NULL;
}

int
ucp_preinit (void)
{
	return 0;
}

void
ucp_postdeinit (void)
{
}
/*}}}*/