ucp.c

使用Modem发送网上传呼

		case 51:
		case 52:
		case 53:
		case 55:
		case 56:
		case 57:
		case 58:
			gstr (& e -> AdC, e -> adc);
			gstr (& e -> OAdC, e -> oadc);
			gstr (& e -> AC, e -> ac);
			gbool (& e -> NRq, e -> nrq, "1", NULL);
			gstr (& e -> NAdC, (e -> nrq ? e -> nadc : NULL));
			gint (& e -> NT, (e -> nrq ? e -> nt : -1), NULL, -1);
			gint (& e -> NPID, (e -> nrq ? e -> npid : -1), "%04d", -1);
			gstr (& e -> na1, NULL);
			gstr (& e -> na2, NULL);
			gstr (& e -> na3, NULL);
			gbool (& e -> DD, e -> dd, "1", NULL);
			if (e -> dd)
				gdate (& e -> DDT, & e -> ddt, 10);
			else
				gstr (& e -> DDT, NULL);
			gdate (& e -> VP, & e -> vp, 10);
			gint (& e -> RPID, e -> rpid, "%04d", -1);
			gdate (& e -> SCTS, & e -> scts, 12);
			gint (& e -> DSt, e -> dst, NULL, -1);
			gint (& e -> Rsn, e -> rsn, "%03d", -1);
			gdate (& e -> DSCTS, & e -> dscts, 12);
			gint (& e -> MT, e -> mt, NULL, 3);
			if (e -> mt == 4)
				if (e -> nb != -1)
					len = e -> nb;
				else
					len = e -> msg ? e -> msg -> len * 8 : 0;
			else
				len = -1;
			gint (& e -> NB, len, NULL, -1);
			if (e -> Msg)
				free (e -> Msg);
			e -> Msg = encode (u, e -> msg, (e -> mt == 4 ? False : True));
			gbool (& e -> MMS, e -> mms, "1", NULL);
			gstr (& e -> na4, NULL);
			gbool (& e -> DCS, e -> dcs, "1", NULL);
			gint (& e -> MCL, e -> mcl, NULL, -1);
			gint (& e -> RPI, e -> rpi, NULL, -1);
			gstr (& e -> na5, NULL);
			gstr (& e -> na6, NULL);
			gstr (& e -> res1, NULL);
			gstr (& e -> res2, NULL);
			gstr (& e -> res3, NULL);
			gstr (& e -> res4, NULL);
			gstr (& e -> res5, NULL);
			if (! (scatc (ret, e -> AdC) && scatc (ret, "/") &&
			       scatc (ret, e -> OAdC) && scatc (ret, "/") &&
			       scatc (ret, e -> AC) && scatc (ret, "/") &&
			       scatc (ret, e -> NRq) && scatc (ret, "/") &&
			       scatc (ret, e -> NAdC) && scatc (ret, "/") &&
			       scatc (ret, e -> NT) && scatc (ret, "/") &&
			       scatc (ret, e -> NPID) && scatc (ret, "/") &&
			       scatc (ret, e -> na1) && scatc (ret, "/") &&
			       scatc (ret, e -> na2) && scatc (ret, "/") &&
			       scatc (ret, e -> na3) && scatc (ret, "/") &&
			       scatc (ret, e -> DD) && scatc (ret, "/") &&
			       scatc (ret, e -> DDT) && scatc (ret, "/") &&
			       scatc (ret, e -> VP) && scatc (ret, "/") &&
			       scatc (ret, e -> RPID) && scatc (ret, "/") &&
			       scatc (ret, e -> SCTS) && scatc (ret, "/") &&
			       scatc (ret, e -> DSt) && scatc (ret, "/") &&
			       scatc (ret, e -> Rsn) && scatc (ret, "/") &&
			       scatc (ret, e -> DSCTS) && scatc (ret, "/") &&
			       scatc (ret, e -> MT) && scatc (ret, "/") &&
			       scatc (ret, e -> NB) && scatc (ret, "/") &&
			       scatc (ret, e -> Msg) && scatc (ret, "/") &&
			       scatc (ret, e -> MMS) && scatc (ret, "/") &&
			       scatc (ret, e -> na4) && scatc (ret, "/") &&
			       scatc (ret, e -> DCS) && scatc (ret, "/") &&
			       scatc (ret, e -> MCL) && scatc (ret, "/") &&
			       scatc (ret, e -> RPI) && scatc (ret, "/") &&
			       scatc (ret, e -> na5) && scatc (ret, "/") &&
			       scatc (ret, e -> na6) && scatc (ret, "/") &&
			       scatc (ret, e -> res1) && scatc (ret, "/") &&
			       scatc (ret, e -> res2) && scatc (ret, "/") &&
			       scatc (ret, e -> res3) && scatc (ret, "/") &&
			       scatc (ret, e -> res4) && scatc (ret, "/") &&
			       scatc (ret, e -> res5) && scatc (ret, "/")))
				fail = True;
			break;
		}
	} else
		fail = True;
	if (! fail) {
		len = ret -> len - 1 + 2;
		sprintf (buf, "%02d/%05d", f -> trn, len);
		if (sputc (ret, buf, 1, -1)) {
			for (n = 1, chk = 0; n < ret -> len; ++n)
				chk += ret -> str[n] & 0xff;
			if (sexpand (ret, ret -> len + 4)) {
				ret -> str[ret -> len++] = hex ((chk >> 4) & 0xf);
				ret -> str[ret -> len++] = hex (chk & 0xf);
				ret -> str[ret -> len++] = '\x03';
			}
		} else
			fail = True;
	}
	if (fail)
		ret = sfree (ret);
	return ret;
}
/*}}}*/
/*{{{	parse */
static date_t
parse_date (char *str)
{
	date_t		ret;
	int		n;
	int		val;
	time_t		tim;
	struct tm	*tt;

	ret.day = 0;
	ret.mon = 0;
	ret.year = 0;
	ret.hour = 0;
	ret.min = 0;
	ret.sec = 0;
	if (str)
		for (n = 0; (n < 6) && *str && *(str + 1); ++n) {
			val = unhex (*str) * 10 + unhex (*(str + 1));
			str += 2;
			switch (n) {
			case 0:	ret.day = val;	break;
			case 1:	ret.mon = val;	break;
			case 2:	ret.year = val;	break;
			case 3:	ret.hour = val;	break;
			case 4:	ret.min = val;	break;
			case 5:	ret.sec = val;	break;
			}
		}
	time (& tim);
	if (tt = localtime (& tim))
		ret.year += ((tt -> tm_year + 1900) / 100) * 100;
	return ret;
}

static string_t *
parse_message (ucp *u, int mt, char *msg)
{
	string_t	*ret;
	int		len;
	int		n;
	char_t		ch;
	void		*ct;
	
	if ((mt != 4) && (u -> ctab))
		ct = cv_reverse (u -> ctab);
	else
		ct = NULL;
	len = strlen (msg);
	if (ret = snew (NULL, len / 2 + 2))
		for (n = 0; n + 1 < len; n += 2) {
			ch = (unhex (msg[n]) << 4) | unhex (msg[n + 1]);
			ret -> str[ret -> len++] = cv_conv (ct, ch);
		}
	if (ct)
		cv_free (ct);
	return ret;
}

static Bool
parse_body (ucp *u, frame *f)
{
	Bool	ret;
	char	*dat, *ptr, *sav;
	char	**rev;
	Bool	done, fail;
	int	n;
	
	if (! (dat = strdup (f -> data)))
		return False;
	ret = False;
	done = False;
	fail = False;
	for (ptr = dat, n = 0; (! done) && (! fail) && ptr; ++n) {
		sav = ptr;
		if (ptr = strchr (ptr, '/'))
			*ptr++ = '\0';
		rev = NULL;
		if (f -> ttyp == 'O') {
			switch (f -> ot) {
			case 1:
				switch (n) {
				case 0:		rev = & f -> b.s.AdC;	break;
				case 1:
					rev = & f -> b.s.OAdC;
					f -> b.s.adc = f -> b.s.AdC ? strdup (f -> b.s.AdC) : NULL;
					break;
				case 2:	
					rev = & f -> b.s.na;
					f -> b.s.oadc = f -> b.s.OAdC ? strdup (f -> b.s.OAdC) : NULL;
					break;
				case 3:		rev = & f -> b.s.MT;	break;
				case 4:
					rev = & f -> b.s.Msg;
					f -> b.s.mt = f -> b.s.MT ? atoi (f -> b.s.MT) : -1;
					done = True;
					break;
				}
				break;
			case 31:
				switch (n) {
				case 0:		rev = & f -> b.s.AdC;	break;
				case 1:	
					rev = & f -> b.s.PID;
					f -> b.s.adc = f -> b.s.AdC ? strdup (f -> b.s.AdC) : NULL;
					done = True;
					break;
				}
				break;
			case 51:
			case 52:
			case 53:
			case 55:
			case 56:
			case 57:
			case 58:
				switch (n) {
				case 0:		rev = & f -> b.e.AdC;	break;
				case 1:
					rev = & f -> b.e.OAdC;
					f -> b.e.adc = f -> b.e.AdC ? strdup (f -> b.e.AdC) : NULL;
					break;
				case 2:
					rev = & f -> b.e.AC;
					f -> b.e.oadc = f -> b.e.OAdC ? strdup (f -> b.e.OAdC) : NULL;
					break;
				case 3:	
					rev = & f -> b.e.NRq;
					f -> b.e.ac = f -> b.e.AC ? strdup (f -> b.e.AC) : NULL;
					break;
				case 4:
					rev = & f -> b.e.NAdC;
					if (f -> b.e.NRq)
						f -> b.e.nrq = (atoi (f -> b.e.NRq) == 1 ? True : False);
					else
						f -> b.e.nrq = False;
					break;
				case 5:	
					rev = & f -> b.e.NT;
					f -> b.e.nadc = f -> b.e.NAdC ? strdup (f -> b.e.NAdC) : NULL;
					break;
				case 6:
					rev = & f -> b.e.NPID;
					f -> b.e.nt = f -> b.e.NT ? atoi (f -> b.e.NT) : 0;
					break;
				case 7:
					rev = & f -> b.e.na1;
					f -> b.e.npid = f -> b.e.NPID ? atoi (f -> b.e.NPID) : -1;
					break;
				case 8:		rev = & f -> b.e.na2;	break;
				case 9:		rev = & f -> b.e.na3;	break;
				case 10:	rev = & f -> b.e.DD;	break;
				case 11:
					rev = & f -> b.e.DDT;
					if (f -> b.e.DD)
						f -> b.e.dd = (atoi (f -> b.e.DD) == 1 ? True : False);
					else
						f -> b.e.dd = False;
					break;
				case 12:
					rev = & f -> b.e.VP;
					f -> b.e.ddt = parse_date (f -> b.e.DDT);
					break;
				case 13:
					rev = & f -> b.e.RPID;
					f -> b.e.vp = parse_date (f -> b.e.VP);
					break;
				case 14:
					rev = & f -> b.e.SCTS;
					f -> b.e.rpid = f -> b.e.RPID ? atoi (f -> b.e.RPID) : -1;
					break;
				case 15:
					rev = & f -> b.e.DSt;
					f -> b.e.scts = parse_date (f -> b.e.SCTS);
					break;
				case 16:
					rev = & f -> b.e.Rsn;
					f -> b.e.dst = f -> b.e.DSt ? atoi (f -> b.e.DSt) : -1;
					break;
				case 17:
					rev = & f -> b.e.DSCTS;
					f -> b.e.rsn = f -> b.e.Rsn ? atoi (f -> b.e.Rsn) : 0;
					break;
				case 18:
					rev = & f -> b.e.MT;
					f -> b.e.dscts = parse_date (f -> b.e.DSCTS);
					break;
				case 19:
					rev = & f -> b.e.NB;
					f -> b.e.mt = f -> b.e.MT ? atoi (f -> b.e.MT) : -1;
					break;
				case 20:
					rev = & f -> b.e.Msg;
					f -> b.e.nb = f -> b.e.NB ? atoi (f -> b.e.NB) : 0;
					break;
				case 21:
					rev = & f -> b.e.MMS;
					if (f -> b.e.Msg)
						if (! (f -> b.e.msg = parse_message (u, f -> b.e.mt, f -> b.e.Msg)))
							fail = True;
					break;
				case 22:
					rev = & f -> b.e.na4;
					if (f -> b.e.MMS)
						f -> b.e.mms = (atoi (f -> b.e.MMS) == 1 ? True : False);
					else
						f -> b.e.mms = False;
					break;
				case 23:	rev = & f -> b.e.DCS;	break;
				case 24:
					rev = & f -> b.e.MCL;
					if (f -> b.e.DCS)
						f -> b.e.dcs = (atoi (f -> b.e.DCS) == 1 ? True : False);
					else
						f -> b.e.dcs = False;
					break;
				case 25:
					rev = & f -> b.e.RPI;
					f -> b.e.mcl = f -> b.e.MCL ? atoi (f -> b.e.MCL) : -1;
					break;
				case 26:
					rev = & f -> b.e.na5;
					f -> b.e.rpi = f -> b.e.RPI ? atoi (f -> b.e.RPI) : -1;
					break;
				case 27:	rev = & f -> b.e.na6;	break;
				case 28:	rev = & f -> b.e.res1;	break;
				case 29:	rev = & f -> b.e.res2;	break;
				case 30:	rev = & f -> b.e.res3;	break;
				case 31:	rev = & f -> b.e.res4;	break;
				case 32:
					rev = & f -> b.e.res5;
					done = True;
					break;
				}
				break;
			}
		} else if (f -> ttyp == 'R') {
			switch (f -> ot) {
			case 1:
			case 31:
				switch (n) {
				case 0:		rev = & f -> b.a.Res;	break;
				case 1:
					if (f -> b.a.Res) {
						if (f -> b.a.Res[0] == 'A') {
							f -> b.a.ack = True;
							rev = & f -> b.a.MSG;
							done = True;
						} else if (f -> b.a.Res[0] == 'N') {
							f -> b.a.ack = False;
							rev = & f -> b.a.EC;
						} else
							fail = True;
					}
					break;
				case 2:
					if (! f -> b.a.ack) {
						f -> b.a.ec = f -> b.a.EC ? atoi (f -> b.a.EC) : -1;
						rev = & f -> b.a.MSG;
						done = True;
					}
					break;
				}
				break;
			case 51:
			case 52:
			case 53:
			case 55:
			case 56:
			case 57:
			case 58:
				switch (n) {
				case 0:		rev = & f -> b.a.Res;	break;
				case 1:
					if (f -> b.a.Res) {
						if (f -> b.a.Res[0] == 'A') {
							f -> b.a.ack = True;
							rev = & f -> b.a.MVP;
						} else if (f -> b.a.Res[0] == 'N') {
							f -> b.a.ack = False;
							rev = & f -> b.a.EC;
						} else
							fail = True;
					} else
						fail = True;
					break;
				case 2:
					if (f -> b.a.ack)
						f -> b.a.mvp = parse_date (f -> b.a.MVP);
					else
						f -> b.a.ec = f -> b.a.EC ? atoi (f -> b.a.EC) : -1;
					rev = & f -> b.a.MSG;
					done = True;
					break;
				}
				break;
			}
		} else
			fail = True;
		if (! fail) {
			if (! rev)
				fail = True;
			else {
				if (*sav) {
					if (! (*rev = strdup (sav)))
						fail = True;
				} else
					*rev = NULL;
			}
			if ((! ptr) && (! done))
				fail = True;
		}
	}
	if (done && (! fail) && (! ptr)) {
		if (f -> ttyp == 'O') {
			switch (f -> ot) {
			case 1:
			case 31:
				if (f -> b.s.Msg)
					if (! (f -> b.s.msg = parse_message (u, f -> b.s.mt, f -> b.s.Msg)))
						fail = True;
				break;
			}
		} else if (f -> ttyp == 'R') {
			switch (f -> ot) {
			case 1:
			case 31:
			case 51:
			case 52:
			case 53:
			case 55:
			case 56:
			case 57:
			case 58:
				if (f -> b.a.MSG) {
					if (! (f -> b.a.adc = strdup (f -> b.a.MSG)))
						fail = True;
					else {
						if (ptr = strchr (f -> b.a.adc, ':'))
							*ptr++ = '\0';
						f -> b.a.scts = parse_date (ptr);
					}
				}
				break;
			}
		} else
			fail = True;
		if (! fail)
			ret = True;
	}
	free (dat);
	return ret;
}

static frame *
parse_frame (ucp *u, char *str)
{
	frame		*f;
	char		*start, *end;
	char		*ptr, *sav;
	int		n, len;
	unsigned int	chksum;
	
	f = NULL;
	if (str = strdup (str)) {
		start = strchr (str, '\x02');
		end = strchr (str, '\x03');
		ptr = strrchr (str, '/');
		if (start && end && (end > start) &&
		    ptr && (start + 1 < ptr) && (ptr + 3 == end) &&
		    (f = new_frame ('\0', 0))) {
			memset (f, 0, sizeof (frame));
			len = (int) ((unsigned long) end - (unsigned long) start) - 1;
			for (chksum = 0, n = 1; n < len - 1; ++n)
				chksum += (unsigned char) start[n];
			chksum &= 0xff;
			ptr = start + 1;
			for (n = 0; n < 4; ++n) {
				if (! (sav = ptr))
					break;
				if (ptr = strchr (ptr, '/'))
					*ptr++ = '\0';
				switch (n) {
				case 0:
					f -> trn = atoi (sav);
					break;
				case 1:
					f -> len = atoi (sav);
					break;
				case 2:
					f -> ttyp = *sav;
					break;
				case 3:
					f -> ot = atoi (sav);
					break;
				}
			}
			sav = ptr;
			if ((n < 4) || (f -> len != len) || (! sav) || (! (ptr = strrchr (sav, '/')))) {
				free (f);
				f = NULL;
			} else {
				f -> cnt = (int) ((unsigned long) ptr - (unsigned long) sav);
				++ptr;
				if (*ptr && *(ptr + 1))
					f -> chksum = (unhex (*ptr) << 4) | unhex (*(ptr + 1));
				else
					f -> chksum = -1;
				if ((chksum == f -> chksum) && (f -> data = malloc (f -> cnt + 1))) {
					memcpy (f -> data, sav, f -> cnt);
					f -> data[f -> cnt] = '\0';
					if (! parse_body (u, f)) {
						free_frame (f);
						f = NULL;
					}
				} else {
					free (f);
					f = NULL;
				}
			}
		}
		free (str);
	}
	return f;
}
/*}}}*/
/*{{{	convert */
static string_t *
convert_ucp (ucp *u, Bool last, string_t *pagerid, string_t *msg)
{
	string_t	*ret;
	frame		*f;
	int		ot;
	int		n;
	int		ch;
	char		*adc, *oadc;
	
	ret = NULL;
	if (! u -> xtend)
		ot = 1;
	else
		ot = 51;
	if (f = new_frame ('O', ot)) {
		f -> trn = u -> cnr++;
		adc = sextract (pagerid);
		oadc = u -> callid ? sextract (u -> callid) : NULL;
		if (msg)
			msg = snew (msg -> str, msg -> len);
		if (u -> xtend) {
			f -> b.e.adc = adc;
			f -> b.e.oadc = oadc;
			if (u -> rds && (u -> delay.day <= 0)) {
				f -> b.e.nrq = True;
				f -> b.e.nt = 7;
			} else
				f -> b.e.nrq = False;
			if (u -> delay.day > 0) {
					f -> b.e.dd = True;
				f -> b.e.ddt = u -> delay;
			} else
				f -> b.e.dd = False;
			if (u -> expire.day > 0)
				f -> b.e.vp = u -> expire;
			for (n = 0; n < msg -> len; ++n)
				if ((ch = cv_conv (u -> ctab, msg -> str[n])) != -1)
					if (ch & 0x80)
						break;
			if (n < msg -> len) {
				f -> b.e.mt = 4;
				f -> b.e.nb = msg -> len * 8;
			} else
				f -> b.e.mt = 3;
			f -> b.e.msg = msg;
		} else {
			f -> b.s.adc = adc;
			f -> b.s.oadc = oadc;
			f -> b.s.mt = 3;
			f -> b.s.msg = msg;
		}
		ret = assemble_frame (u, f);
		free_frame (f);
	}
	return ret;
}
/*}}}*/
/*{{{	callback interface */
static void
grabline (void *sp, string_t *s, char_t sep, void *data)
{
	ucp	*u = (ucp *) data;
	char	*str;