yaps.c

使用Modem发送网上传呼

							err = scr_execute (s, smsg, tmp);
						else
							err = ERR_FATAL;
						if (err == NO_ERR)
							mg[n].st.success = True;
						else
							mg[n].st.reason = CantSend;
						do_log ((err == NO_ERR ? LGS_INF : LGF_INF),
							"SCRIPT message %s %ssent via %s", (tmp ? tmp : ""), (err == NO_ERR ? "" : "NOT "), service);
						do_log ((err == NO_ERR ? LGS_SENT : LGF_SENT),
							"SCRIPT Message %ssent to %s via %s: %s", (err == NO_ERR ? "" : "NOT "),
							(mg[n].alias ? mg[n].alias : (mg[n].pid ? mg[n].pid : "")), service, (tmp ? tmp : ""));
						if (ESTOP (err))
							break;
					}
					if (n + 1 < mcnt) {
						if (err == NO_ERR)
							err = scr_execute (s, snext, NULL);
						else
							err = scr_execute (s, ssync, NULL);
						if (ESTOP (err))
							break;
						else if (err != NO_ERR)
							if ((nerr = scr_execute (s, ssync, NULL)) != NO_ERR) {
								if (nerr < err)
									err = nerr;
								break;
							}
					}
				}
				if (n < mcnt)
					ret = 1;
				if ((err != ERR_ABORT) && (scr_execute (s, slogout, NULL) != NO_ERR))
					ret = 1;
			} else
				ret = 1;
		}
		scr_free (s);
	}
	return ret;
}
/*}}}*/
/*{{{	send TAP */
static int
tap_send (void *sp, void *ctab, string_t *callid, message *mg, int mcnt, void *cfg, char *service, date_t *delay, date_t *expire, Bool rds)
{
	void		*tp;
	string_t	*field[4];
	int		fld;
	int		n;
	char		*tmp;
	int		err, nerr;
	
	if (! (tp = tap_new (sp)))
		return 1;
	tap_timeouts (tp,
		      cfg_iget (cfg, service, CFG_T1, DEF_T1),
		      cfg_iget (cfg, service, CFG_T2, DEF_T2),
		      cfg_iget (cfg, service, CFG_T3, DEF_T3),
		      cfg_iget (cfg, service, CFG_T4, DEF_T4),
		      cfg_iget (cfg, service, CFG_T5, DEF_T5));
	tap_retries (tp,
		     cfg_iget (cfg, service, CFG_N1, DEF_N1),
		     cfg_iget (cfg, service, CFG_N2, DEF_N2),
		     cfg_iget (cfg, service, CFG_N3, DEF_N3),
		     cfg_iget (cfg, service, CFG_TLICNT, DEF_TLICNT),
		     cfg_iget (cfg, service, CFG_TLOCNT, DEF_TLOCNT));
	tap_config (tp, do_log, cfg_bget (cfg, service, CFG_TOLD, DEF_TOLD));
	if (ctab) {
		tap_add_convtable (tp, ctab);
		ctab = cv_free (ctab);
	}
	if (tap_login (tp, NULL, '\0', NULL, callid) != NO_ERR) {
		tap_free (tp);
		return 1;
	}
	err = NO_ERR;
	for (n = 0; n < mcnt; ++n) {
		fld = 0;
		field[fld++] = snewc (mg[n].pid);
		field[fld++] = snew (mg[n].msg -> str, mg[n].msg -> len);
		field[fld] = NULL;
		nerr = tap_transmit (tp, field, (n + 1 < mcnt ? False : True));
		if (nerr == NO_ERR)
			mg[n].st.success = True;
		else
			mg[n].st.reason = CantSend;
		tmp = schar (mg[n].msg);
		do_log ((nerr == NO_ERR ? LGS_SENT : LGF_SENT),
			"TAP Message %ssent to %s via %s: %s", (nerr == NO_ERR ? "" : "NOT "),
			(mg[n].alias ? mg[n].alias : (mg[n].pid ? mg[n].pid : "")), service,
			(tmp ? tmp : ""));
		if (nerr != NO_ERR)
			err = nerr;
		for (fld = 0; field[fld]; ++fld)
			sfree (field[fld]);
		if (ESTOP (err))
			break;
	}
	if ((err != ERR_ABORT) && ((n = tap_logout (tp)) != NO_ERR))
		if (err == NO_ERR)
			err = n;
	tap_free (tp);
	return (err != NO_ERR) ? 1 : 0;
}
/*}}}*/
/*{{{	send UCP */
static int
ucp_send (void *sp, void *ctab, string_t *callid, message *mg, int mcnt, void *cfg, char *service, date_t *delay, date_t *expire, Bool rds)
{
	void		*up;
	int		n;
	int		err, nerr;
	string_t	*pid;
	char		*tmp;	

	if (! (up = ucp_new (sp)))
		return 1;
	err = ERR_FATAL;
	if (ctab) {
		ucp_add_convtable (up, ctab);
		ctab = cv_free (ctab);
	}
	ucp_config (up, do_log,
		    cfg_bget (cfg, service, CFG_UXTEND, DEF_UXTEND),
		    cfg_iget (cfg, service, CFG_USTOUT, DEF_USTOUT),
		    cfg_iget (cfg, service, CFG_URETRY, DEF_URETRY),
		    cfg_iget (cfg, service, CFG_URTOUT, DEF_URTOUT),
		    delay, expire, rds);
	if ((err = ucp_login (up, callid)) == NO_ERR) {
		for (n = 0; n < mcnt; ++n) {
			pid = snewc (mg[n].pid);
			if (pid) {
				nerr = ucp_transmit (up, pid, mg[n].msg, (n + 1 < mcnt ? False : True));
				if (nerr == NO_ERR)
					mg[n].st.success = True;
				else
					mg[n].st.reason = CantSend;
			} else
				nerr = ERR_FATAL;
			sfree (pid);
			tmp = schar (mg[n].msg);
			do_log ((nerr == NO_ERR ? LGS_SENT : LGF_SENT),
				"UCP Message %ssent to %s via %s: %s", (nerr == NO_ERR ? "" : "NOT "),
				(mg[n].alias ? mg[n].alias : (mg[n].pid ? mg[n].pid : "")), service,
				(tmp ? tmp : ""));
			if (nerr != NO_ERR)
				err = nerr;
			if (ESTOP (err))
				break;
		}
		if ((err != ERR_ABORT) && ((n = ucp_logout (up)) != NO_ERR))
			if (err == NO_ERR)
				err = n;
	}
	ucp_free (up);
	return (err != NO_ERR) ? 1 : 0;
}
/*}}}*/
/*{{{	support routines */
static Protocol
getproto (char *str)
{
	if (str)
		if (! strcmp (str, "ascii"))
			return Ascii;
		else if (! strcmp (str, "script"))
			return Script;
		else if (! strcmp (str, "tap"))
			return Tap;
		else if (! strcmp (str, "ucp"))
			return Ucp;
	return Unknown;
}

static string_t *
readfile (char *fname)
{
	FILE		*fp;
	string_t	*str;
	int		size;
	struct stat	st;
	
	str = NULL;
	if (fp = fopen (fname, "r")) {
		size = 0;
		if (fstat (fileno (fp), & st) != -1)
			size = st.st_size;
		if ((size > 0) && (str = snew (NULL, size + 1)))
			if (fread (str -> str, sizeof (char), size, fp) == size)
				str -> len = size;
			else
				str = sfree (str);
		fclose (fp);
	}
	return str;
}

static string_t *
read_stdin (void)
{
	string_t	*str;
	int		ch;
	
	if (str = snew (NULL, 256))
		while ((ch = getchar ()) != EOF) {
			if (str -> len >= str -> size)
				sexpand (str, str -> size + 64);
			str -> str[str -> len++] = (char_t) ch;
		}
	return str;
}

static void
extend_convtable (void *ctab, void *cfg, char *service)
{
	char	*str;
	char	*cv, *cvs;
	char	*ptr, *sav;
	char	*src, *dst;
	int	n;
	char	*defconv[] = {
		"no-control",
		"control",
		"no-8bit",
		"8bit",
		"numeric",
		NULL
	};
	
	if ((str = cfg_get (cfg, service, CFG_CONVERT, DEF_CONVERT)) &&
	    (str = strdup (str))) {
		for (cv = str; *cv; ) {
			cvs = cv;
			cv = skipch (cv, ',');
			if (*cvs == '*') {
				++cvs;
				for (n = 0; defconv[n]; ++n)
					if (! strcmp (cvs, defconv[n]))
						break;
				switch (n) {
				case 0:		/* no-control */
					for (n = 0; n < 32; ++n) {
						cv_invalid (ctab, (char_t) n);
						cv_invalid (ctab, (char_t) (n | 0x80));
					}
					cv_invalid (ctab, (char_t) '\x7f');
					break;
				case 1:		/* control */
					for (n = 0; n < 32; ++n) {
						cv_undefine (ctab, (char_t) n);
						cv_undefine (ctab, (char_t) (n | 0x80));
					}
					cv_undefine (ctab, (char_t) '\x7f');
					break;
				case 2:		/* no-8bit */
					for (n = 128; n < 256; ++n)
						cv_invalid (ctab, (char_t) n);
					break;
				case 3:		/* 8bit */
					for (n = 128; n < 256; ++n)
						cv_undefine (ctab, (char_t) n);
					break;
				case 4:		/* numeric */
					for (n = 0; n < 256; ++n)
						if (n && strchr ("0123456789", (char) n))
							cv_undefine (ctab, (char_t) n);
						else
							cv_invalid (ctab, (char_t) n);
					break;
				}
			} else if ((cvs = cfg_get (cfg, service, cvs, NULL)) &&
				   (cvs = strdup (cvs))) {
				for (ptr = cvs; ptr; ) {
					sav = ptr;
					if (ptr = strchr (ptr, '\n'))
						*ptr++ = '\0';
					for (src = sav; isspace (*src); ++src)
						;
					if (*src && (*src != '#')) {
						dst = skip (src);
						if (*src && *dst)
							cv_sdefine (ctab, src, dst);
					}
				}
				free (cvs);
			}
		}
		free (str);
	}
}

static int
check (char *str, char *pat)
{
	Bool	done, incs;
	char	*ptr, *sav, *val;
	int	slen;
	int	n, m, chk;
	char	*p;
	char	*chtab[] = {
		"type",
		"length",
		"minimum",
		"maximum",
		NULL
	},	*tytab[] = {
		"numeric",
		"sedecimal",
		"lower",
		"upper",
		"alpha",
		"alphanumeric",
		"print",
		"ascii",
		NULL
	};

	if (! pat)
		return 0;
	done = False;
	if (*pat == '+') {
		++pat;
		if (pat = strdup (pat)) {
			done = True;
			slen = strlen (str);
			for (ptr = pat; *ptr && done; ) {
				sav = ptr;
				ptr = skipch (ptr, ',');
				val = skipch (sav, '=');
				for (n = 0; chtab[n]; ++n)
					if (! strcmp (sav, chtab[n]))
						break;
				switch (n) {
				case 0:		/* type */
					for (m = 0; tytab[m]; ++m)
						if (! strcmp (val, tytab[m]))
							break;
					for (p = str; *p; ++p) {
						switch (m) {
						default:
							chk = 1;
							break;
						case 0:		/* numeric */
							chk = isdigit (*p);
							break;
						case 1:		/* sedecimal */
							chk = isxdigit (*p);
							break;
						case 2:		/* lower */
							chk = islower (*p);
							break;
						case 3:		/* upper */
							chk = isupper (*p);
							break;
						case 4:		/* alpha */
							chk = isalpha (*p);
							break;
						case 5:		/* alphanumeric */
							chk = isalnum (*p);
							break;
						case 6:		/* print */
							chk = isprint (*p);
							break;
						case 7:		/* ascii */
							chk = isascii (*p);
							break;
						}
						if (! chk)
							return -1;
					}
					break;
				case 1:		/* length */
					if (slen != atoi (val))
						return -1;
					break;
				case 2:		/* minimum */
					if (slen < atoi (val))
						return -1;
					break;
				case 3:		/* maximum */
					if (slen > atoi (val))
						return -1;
					break;
				}
			}
		}
		if (! done)
			return -1;
	} else {
		while (*str && *pat) {
			incs = True;
			switch (tolower (*pat)) {
			case '>':
				done = True;
				incs = False;
				break;
			case '<':
				return -1;
				break;
			case '1':
				if (! isdigit (*str))
					return -1;
				break;
			case 'h':
				if (! isxdigit (*str))
					return -1;
				break;
			case 'l':
				if (! islower (*str))
					return -1;
				break;
			case 'u':
				if (! isupper (*str))
					return -1;
				break;
			case 'a':
				if (! isalpha (*str))
					return -1;
				break;
			case 'n':
				if (! isalnum (*str))
					return 1;
				break;
			case 'p':
				if (! isprint (*str))
					return -1;
				break;
			case 'x':
				if (! isascii (*str))
					return -1;
				break;
			}
			if ((! done) || *(pat + 1))
				++pat;
			if (incs)
				++str;
		}
		if ((! done) && (*str || *pat))
			return -1;
	}
	return 0;
}
/*}}}*/
/*{{{	preparse receiver and messages */
static int
ncompare (const void *a, const void *b)
{
	return ((message *) a) -> nr - ((message *) b) -> nr;
}

static int
mcompare (const void *a, const void *b)
{
	const message	*am = (message *) a,
			*bm = (message *) b;
	int		n;

	n = strcmp (am -> service, bm -> service);
	if (! n)
		n = strcmp (am -> pid, bm -> pid);
	return n;
}

static char *
do_replace (char *str, int start, int len, char *rplc, int rlen)
{
	int	n, m;
	int	slen, diff;

	if (rlen > len) {
		slen = strlen (str);
		diff = rlen - len;
		if (! (str = Realloc (str, slen + diff + 2)))
			return NULL;
		for (n = slen; n >= start + len; --n)
			str[n + diff] = str[n];
		str[slen + diff] = '\0';
	} else if (rlen < len) {
		for (n = start + rlen, m = start + len; str[m]; ++n, ++m)
			str[n] = str[m];
		str[n] = '\0';
	}
	if (rlen > 0)
		memcpy (str + start, rplc, rlen);
	return str;
}

static void
remove_invalids (char *str, char *rmv)
{
	int	m, n;
	char	*ptr;
	
	for (n = 0, m = 0; str[n]; ++n) {
		for (ptr = rmv; *ptr; ++ptr)
			if (*ptr == str[n])
				break;
		if (! *ptr)
			if (n != m)
				str[m++] = str[n];
			else
				++m;
	}
	str[m] = '\0';
}

static message *
create_messages (void *cfg, char *service, serv *sbase, char **argv, int argc, char *mfile, int *mcnt,
		 char *callid, char *sig, Bool trunc, Bool force, date_t *delay, date_t *expire, Bool rds)
{
	char		**recv;
	int		rcnt, rsiz;
	FILE		*fp;
	message		*mg;
	int		cnt, siz;
	Bool		lforce;
	serv		*srun;
	int		n, m, len;
	char		*str, *ptr, *sav, *tstr, *tptr;
	string_t	*fstdin;
	Bool		isalias;
	Bool		doins;
	int		rsize;
	string_t	*tmp;
	char		*rmv;
	char		*rplc;
	int		start, end;
	Bool		ttrunc;
	char		*tsig;
	int		msize;
	Bool		msplit;
	char		*sr;

	rcnt = 0;
	rsiz = 0;
	recv = NULL;
	for (n = 0; n < argc; ++n) {
		if (rcnt + 2 >= rsiz) {
			rsiz += 16;
			if (! (recv = (char **) Realloc (recv, (rsiz + 2) * sizeof (char *)))) {
				OOM;
				return NULL;
			}
		}
		if (! (recv[rcnt] = strdup (argv[n]))) {
			OOM;
			return NULL;
		}
		++rcnt;
	}
	if (mfile) {
		if (! (fp = fopen (mfile, "r"))) {
			fprintf (stderr, "Unable to open message file %s for reading\n", mfile);
			return NULL;
		}
		while (ptr = getline (fp, False)) {
			sav = skip (ptr);
			if (*ptr && *sav) {
				if (rcnt + 2 >= rsiz) {
					rsiz += 16;
					if (! (recv = (char **) Realloc (recv, (rsiz + 2) * sizeof (char *)))) {
						OOM;
						return NULL;
					}
				}
				if ((! (recv[rcnt] = strdup (ptr))) ||
				    (! (recv[rcnt + 1] = strdup (sav)))) {
					OOM;
					return NULL;
				}
				rcnt += 2;
			}
		}
		fclose (fp);
	}
	if (! recv) {
		fprintf (stderr, "No receiver found\n");
		return NULL;
	}
	recv[rcnt] = NULL;

	for (n = 0; n < rcnt; n += 2) {
		ptr = recv[n];
		if (((! isdigit (*ptr)) || (*ptr == ':')) && (*ptr != '\\')) {
			if (*ptr == ':')
				++ptr;
			if (! (str = strdup (ptr))) {
				OOM;
				return NULL;
			}
			m = 0;
			tstr = 0;
			for (ptr = str; *ptr; ) {
				sav = ptr;
				ptr = skipch (ptr, ',');
				if ((! (tptr = cfg_block_get (cfg, SEC_ALIAS, sav, NULL))) ||
				    (! strchr (tptr, ',')))
					tptr = sav;
				len = strlen (tptr);
				if (tstr = Realloc (tstr, m + len + 2)) {
					if (m)
						tstr[m++] = ',';
					strcpy (tstr + m, tptr);
					m += len;
				}
			}
			free (str);
			free (recv[n]);
			if (! (recv[n] = tstr)) {
				OOM;
				return NULL;
			}
		}
	}

	mg = NULL;
	cnt = 0;
	siz = 0;
	fstdin = NULL;
	for (n = 0; n < rcnt; n += 2)
		if (str = recv[n]) {
			for (ptr = str; *ptr; ) {