yaps.c

使用Modem发送网上传呼

				m = n;
		if (m != -1)
			cnt = m + 1;
		tty_hangup (sp, 500);
		time (& end);
		diff = (int) (end - start);
		if (ptr = calc_cost (cfg, sr, start, diff))
			if (! mg[cur].st.rmsg)
				mg[cur].st.rmsg = ptr;
			else
				free (ptr);
		do_log (LG_ESESSION, "Session %s on service %s (duration %d:%02d)", (err ? "failed" : "succeeded"), sr, diff / 60, diff % 60);
		reset = cfg_get (cfg, modem, CFG_RESET, DEF_RESET);
		if (reset) {
			tout = cfg_iget (cfg, modem, CFG_TIMEOUT, DEF_TIMEOUT);
			tty_send_expect (sp, tout, reset, NULL);
		}
		tty_close (sp);
		if (modem)
			free (modem);
		if ((sig == SIGTERM) || (sig == SIGQUIT))
			longjmp (termenv, sig);
	} else {
		for (n = cur + 1; n < mcnt; ++n)
			if (strcmp (sr, mg[n].service))
				break;
		cnt = n - cur;
		for (n = 0; n < cnt; ++n)
			mg[cur + n].st.reason = CantDial;
		do_log (LG_ESESSION, "Unable to dial service %s", sr);
		fprintf (stderr, "Unable to dial %s\n", sr);
		err = 1;
	}
	if (err)
		*rerr = err;
	return cur + cnt;
}
/*}}}*/
/*{{{	print configuration values */
static void
print_config (void *cfg, char *service, char **vars)
{
	int	n;
	char	*val;
	
	while (*vars) {
		printf ("%s ->", *vars);
		for (n = service ? 0 : 1; n < 2; ++n) {
			if (n && service)
				printf (" (");
			else
				printf (" ");
			if (val = n ? cfg_get (cfg, NULL, *vars, NULL) : cfg_block_get (cfg, service, *vars, NULL))
				printf ("%s", val);
			else
				printf ("*none*");
			if (n && service)
				printf (")");
			if (! n)
				printf (" ->");
			else
				printf ("\n");
		}
		++vars;
	}
}
/*}}}*/
/*{{{	getopt */
# if		! HAVE_GETOPT && ! HAVE_GETOPT_LONG
# if		NEED_OPTIND_OPTARG
# undef		NEED_OPTIND_OPTARG
# endif		/* NEED_OPTIND_OPTARG */
static int	optind = 1;
static int	optidx = 0;
static char	*optarg = NULL;

static int
getopt (int argc, char **argv, char *what)
{
	char	ch, *ptr;
	
	optarg = NULL;
	if (optind >= argc)
		return -1;
	do {
		if (! argv[optind][optidx]) {
			optidx = 0;
			++optind;
			if (optind >= argc)
				return -1;
		}
		if (optidx == 0) 
			if (argv[optind][0] != '-')
				return -1;
			else
				optidx = 1;
	}	while (! optidx);
	if ((optidx == 1) && (argv[optind][optidx] == '-') && (! argv[optind][optidx + 1])) {
		++optind;
		return -1;
	}
	ch = argv[optind][optidx++];
	if (! (ptr = strchr (what, ch))) {
		fprintf (stderr, "%s: Unknown option -%c\n", argv[0] ? argv[0] : "", ch);
		return '?';
	}
	++ptr;
	if (*ptr == ':')
		if (argv[optind][optidx]) {
			optarg = (argv[optind]) + optidx;
			++optind;
			optidx = 0;
		} else {
			++optind;
			if (optind < argc)
				optarg = argv[optind++];
			else {
				fprintf (stderr, "%s: Missiong parameter for option -%c\n", argv[0] ? argv[0] : "", ch);
				ch = ':';
			}
			optidx = 0;
		}
	return ch;
}
# endif		/* ! HAVE_GETOPT && ! HAVE_GETOPT_LONG */
/*}}}*/
/*{{{	usage/version */
static void
usage (char *pgm)
{
# if		HAVE_GETOPT_LONG
# define	PLONG(xxx)		fprintf xxx
# else		/* HAVE_GETOPT_LONG */
# define	PLONG(xxx)		putc ('\t', stderr)
# endif		/* HAVE_GETOPT_LONG */
	fprintf (stderr, "Usgae: %s [<opts>] {<pagerid> <message>}+\n", pgm);
	fprintf (stderr, "Function: sends messages to paging devices\n");
	fprintf (stderr, "Options:\n");
	PLONG ((stderr, "\t--config=<fname>,          "));
	fprintf (stderr, "-C <fname>      uses alternate global configurtion file\n");
	PLONG ((stderr, "\t--service=<service>,       "));
	fprintf (stderr, "-s <service>    use this service, if applicated\n");
	PLONG ((stderr, "\t--truncate,                "));
	fprintf (stderr, "-t              truncates too long messages\n");
	PLONG ((stderr, "\t--call-id=<callid>,        "));
	fprintf (stderr, "-c <callid>     if possible, use this caller id\n");
	PLONG ((stderr, "\t--signature=<signature>,   "));
	fprintf (stderr, "-S <sig>        add this signature to the message\n");
	PLONG ((stderr, "\t--logfile=<fname>,         "));
	fprintf (stderr, "-l <fname>      log activities to a file\n");
	PLONG ((stderr, "\t--logstring=<string>,      ")),
	fprintf (stderr, "-L <string>     log only these activities\n");
	PLONG ((stderr, "\t--force,                   "));
	fprintf (stderr, "-f              force sending, even if -d/-e/-r is not supported\n");
	PLONG ((stderr, "\t--delay=<date>,            "));
	fprintf (stderr, "-d <date>       when to send the message (if supported)\n");
	PLONG ((stderr, "\t--expire=<date>,           "));
	fprintf (stderr, "-e <date>       when should the mesage expire (if supported)\n");
	PLONG ((stderr, "\t--request-delivery-status, "));
	fprintf (stderr, "-r              request delivery report (if supported)\n");
	PLONG ((stderr, "\t--final-report=<fname>,    "));
	fprintf (stderr, "-R <fname>      store the final report to <fname>\n");
	PLONG ((stderr, "\t--message=file=<fname>,    "));
	fprintf (stderr, "-z <fname>      read pager-id/message pairs from <fname>\n");
	PLONG ((stderr, "\t--verbose[=<level>],       "));
	fprintf (stderr, "-v              increase verbosity\n");
	fprintf (stderr, "\t<pagerid>       this is the receiver of the message\n");
	fprintf (stderr, "\t<message>       the message, if it is prefixed by a plus sign (+), then the remaining part\n");
	fprintf (stderr, "\t                is taken as a filename from where the message is read\n");
	fprintf (stderr, "\n");
	PLONG ((stderr, "\t--print-config,            "));
	fprintf (stderr, "-p              print configuration variables/values\n");
	fprintf (stderr, "\t                the arguments are the variable names to be displayed\n");
	PLONG ((stderr, "\t--version,                 "));
	fprintf (stderr, "-V              show version and compile informations\n");
# ifdef		VERSION
	fprintf (stderr, "\nVersion: %s\n", VERSION);
# endif		/* VERSION */
# undef		PLONG	
}

static void
show_version (char *pgm)
{
	printf ("%s: V. %s\n", pgm ? pgm : "yaps", VERSION);
	printf ("Definitions:");
# if		POSIX_SIGNAL
	printf (" POSIX_SIGNAL");
# endif		/* POSIX_SIGNAL */
# if		BSD_SIGNAL
	printf (" BSD_SIGNAL");
# endif		/* BSD_SIGNAL */
# if		SYSV_SIGNAL
	printf (" SYSV_SIGNAL");
# endif		/* SYSV_SIGNAL */
# if		SIG_VOID_RETURN
	printf (" SIG_VOID_RETURN");
# endif		/* SIG_VOID_RETURN */
# if		SIG_INT_RETURN
	printf (" SIG_INT_RETURN");
# endif		/* SIG_INT_RETURN */
# if		HAVE_SYS_SELECT_H
	printf (" HAVE_SYS_SELECT_H");
# endif		/* HAVE_SYS_SELECT_H */
# if		HAVE_LOCALE_H
	printf (" HAVE_LOCALE_H");
# endif		/* HAVE_LOCALE_H */
# if		HAVE_REGEX_H
	printf (" HAVE_REGEX_H");
# endif		/* HAVE_REGEX_H */
# if		HAVE_SYS_SYSMACROS_H
	printf (" HAVE_SYS_SYSMACROS_H");
# endif		/* HAVE_SYS_SYSMACROS_H */
# if		HAVE_SYS_MKDEV_H
	printf (" HAVE_SYS_MKDEV_H");
# endif		/* HAVE_SYS_MKDEV_H */
# if		HAVE_GETOPT_H
	printf (" HAVE_GETOPT_H");
# endif		/* HAVE_GETOPT_H */
# if		HAVE_TZSET
	printf (" HAVE_TZSET");
# endif		/* HAVE_TZSET */
# if		HAVE_FCHMOD
	printf (" HAVE_FCHMOD");
# endif		/* HAVE_FCHMOD */
# if		HAVE_FCHOWN
	printf (" HAVE_FCHOWN");
# endif		/* HAVE_FCHOWN */
# if		HAVE_SIGSETJMP
	printf (" HAVE_SIGSETJMP");
# endif		/* HAVE_SIGSETJMP */
# if		HAVE_MEMCPY
	printf (" HAVE_MEMCPY");
# endif		/* HAVE_MEMCPY */
# if		HAVE_BCOPY
	printf (" HAVE_BCOPY");
# endif		/* HAVE_BCOPY */
# if		HAVE_MEMSET
	printf (" HAVE_MEMSET");
# endif		/* HAVE_MEMSET */
# if		HAVE_BZERO
	printf (" HAVE_BZERO");
# endif		/* HAVE_BZERO */
# if		HAVE_GETOPT
	printf (" HAVE_GETOPT");
# endif		/* HAVE_GETOPT */
# if		HAVE_GETOPT_LONG
	printf (" HAVE_GETOPT_LONG");
# endif		/* HAVE_GETOPT_LONG */
# if		NEED_OPTIND_OPTARG
	printf (" NEED_OPTIND_OPTARG");
# endif		/* NEED_OPTIND_OPTARG */
# if		BROKEN_REALLOC
	printf (" BROKEN_REALLOC");
# endif		/* BROKEN_REALLOC */
	printf ("\n");
}
/*}}}*/
/*{{{	main */
# if		HAVE_GETOPT_LONG
static struct option	opttab[] = {
	{	"config",	required_argument,	NULL,	'C'	},
	{	"service",	required_argument,	NULL,	's'	},
	{	"truncate",	no_argument,		NULL,	't'	},
	{	"call-id",	required_argument,	NULL,	'c'	},
	{	"signature",	required_argument,	NULL,	'S'	},
	{	"logfile",	required_argument,	NULL,	'l'	},
	{	"logstring",	required_argument,	NULL,	'L'	},
	{	"force",	no_argument,		NULL,	'f'	},
	{	"delay",	required_argument,	NULL,	'd'	},
	{	"expire",	required_argument,	NULL,	'e'	},
	{	"request-delivery-status", no_argument,	NULL,	'r'	},
	{	"final-report",	required_argument,	NULL,	'R'	},
	{	"message-file",	required_argument,	NULL,	'z'	},
	{	"verbose",	optional_argument,	NULL,	'v'	},
	{	"print-config",	no_argument,		NULL,	'p'	},
	{	"version",	no_argument,		NULL,	'V'	},
	{	"help",		no_argument,		NULL,	'h'	},
	{	NULL,		0,			NULL,	0	}
};
# define	GETOPT(what)		getopt_long (argc, argv, (what), opttab, NULL)
# else		/* HAVE_GETOPT_LONG */
# define	GETOPT(what)		getopt (argc, argv, (what))
# endif		/* HAVE_GETOPT_LONG */

int
main (int argc, char **argv)
{
# if		NEED_OPTIND_OPTARG
	extern int	optind;
	extern char	*optarg;
# endif		/* NEED_OPTIND_OPTARG */
	char		*cfgfile;
	void		*cfg;
	char		*home, *lfn;
	int		n, m;
	int		ret;
	char		*svcs;
	serv		*sbase, *sprev, *stmp;
	char		*chk;
	char		*service;
	Bool		trunc;
	char		*callid;
	char		*sig;
	Bool		force;
	date_t		*delay, *expire;
	Bool		rds;
	char		*freport;
	FILE		*fp;
	char		*mfile;
	Bool		pcfg;
	date_t		*cur;
	message		*mg;
	int		mcnt;
	int		onr;
	Bool		succ;
	char		*ptr, *sav;
# if		POSIX_SIGNAL
	struct sigaction
			sact, sign;
# endif		/* POSIX_SIGNAL */

	cfgfile = CFGFILE;
	service = NULL;
	trunc = False;
	callid = NULL;
	sig = NULL;
	force = False;
	delay = NULL;
	expire = NULL;
	rds = False;
	freport = NULL;
	mfile = NULL;
	pcfg = False;
	logfile = NULL;
	logstr = NULL;
	verbose = -1;
# if		HAVE_TZSET	
	tzset ();
# endif		/* HAVE_TZSET */
# if		HAVE_LOCALE_H
	setlocale (LC_ALL, "");
# endif		/* HAVE_LOCALE_H */
	while ((n = GETOPT ("C:s:tc:S:l:L:fd:e:rR:z:vpVh")) != -1)
		switch (n) {
		case 'C':
			cfgfile = optarg;
			break;
		case 's':
			service = optarg;
			break;
		case 't':
			trunc = True;
			break;
		case 'c':
			callid = optarg;
			break;
		case 'S':
			sig = optarg;
			break;
		case 'l':
			logfile = optarg;
			break;
		case 'L':
			logstr = optarg;
			break;
		case 'f':
			force = True;
			break;
		case 'd':
			if (delay)
				delay = dat_free (delay);
			if (! (delay = dat_parse (optarg))) {
				fprintf (stderr, "Invalid date format for delay\n");
				return 1;
			}
			break;
		case 'e':
			if (expire)
				expire = dat_free (expire);
			if (! (expire = dat_parse (optarg))) {
				fprintf (stderr, "Invalid date format for expire\n");
				return 1;
			}
			break;
		case 'r':
			rds = True;
			break;
		case 'R':
			freport = optarg;
			break;
		case 'z':
			mfile = optarg;
			break;
		case 'v':
# if		HAVE_GETOPT_LONG
			if (optarg)
				verbose = atoi (optarg);
			else
# endif		/* HAVE_GETOPT_LONG */
			if (verbose < 0)
				verbose = 1;
			else
				++verbose;
			break;
		case 'p':
			pcfg = True;
			break;
		case 'V':
			show_version (argv[0]);
			return 0;
		case 'h':
		default:
			usage (argv[0]);
			return n == 'h' ? 0 : 1;
		}
	if (delay || expire) {
		if (cur = dat_parse (NULL)) {
			if (delay && (dat_diff (cur, delay) < 0)) {
				fprintf (stderr, "Delay is before now, invalid\n");
				return 1;
			}
			if (expire && (dat_diff (cur, expire) < 0)) {
				fprintf (stderr, "Expiration already reached\n");
				return 1;
			}
			dat_free (cur);
		}
		if (delay && expire)
			if (dat_diff (delay, expire) < 0) {
				fprintf (stderr, "Message expires before it should be send\n");
				return 1;
			}
	}
	cfg = cfg_read (cfgfile, NULL, CONFIG_SEP);
	if ((home = getenv ("HOME")) && (lfn = malloc (strlen (home) + sizeof (LCFGFILE) + 4))) {
		sprintf (lfn, "%s/%s", home, LCFGFILE);
		cfg = cfg_read (lfn, cfg, CONFIG_SEP);
		free (lfn);
	}
	if (pcfg) {
		print_config (cfg, service, argv + optind);
		return 0;
	}
	if (((optind == argc) && (! mfile)) || ((argc - optind) & 1)) {
		if ((optind == argc) && (! mfile))
			fprintf (stderr, "No message\n");
		if ((argc - optind) & 1)
			fprintf (stderr, "Unbalanced pagerid/message\n");
		usage (argv[0]);
		return 1;
	}
	if (mfile && (access (mfile, R_OK) < 0)) {
		fprintf (stderr, "Unable to read message file %s\n", mfile);
		return 1;
	}
	if (verbose < 0)
		verbose = cfg_iget (cfg, NULL, CFG_VERBOSE, 0);
	if (! logfile)
		logfile = cfg_get (cfg, NULL, CFG_LOGFILE, NULL);
	if (! logstr)
		logstr = cfg_get (cfg, NULL, CFG_LOGSTR, NULL);
	if (! (svcs = cfg_get (cfg, NULL, CFG_SERVICES, NULL))) {
		fprintf (stderr, "No services definied\n");
		return 1;
	}
	if (! (svcs = strdup (svcs))) {
		OOM;
		return 1;
	}
	sbase = NULL;
	sprev = NULL;
	for (ptr = svcs; *ptr; ) {
		sav = ptr;
		ptr = skipch (ptr, ',');
		if (! (chk = cfg_block_get (cfg, sav, CFG_VALPID, NULL))) {
			fprintf (stderr, "Service %s has no pattern for matching pager ids\n", sav);
			return 1;
		}
		if ((stmp = (serv *) malloc (sizeof (serv))) &&
		    (stmp -> name = strdup (sav))) {
			if (! (stmp -> pchk = v_new (chk))) {
				fprintf (stderr, "Pattern %s in service %s is not valid\n", chk, sav);
				return 1;
			}
			stmp -> cchk = NULL;
			if (chk = cfg_get (cfg, sav, CFG_VALCID, NULL))
				if (! (stmp -> cchk = v_new (chk))) {
					fprintf (stderr, "Pattern %s in service %s not valid\n", chk, sav);
					return 1;
				}
			stmp -> next = NULL;
			if (sprev)
				sprev -> next = stmp;
			else
				sbase = stmp;
			sprev = stmp;
		} else {
			OOM;
			return 1;
		}
	}
	if (! sbase) {
		fprintf (stderr, "No services found\n");
		return 1;
	}
	if (! (mg = create_messages (cfg, service, sbase, argv + optind, argc - optind, mfile, & mcnt, callid, sig, trunc, force, delay, expire, rds)))
		return 1;
	while (sbase) {
		stmp = sbase;
		sbase = sbase -> next;
		free (stmp -> name);
		v_free (stmp -> pchk);
		if (stmp -> cchk)
			v_free (stmp -> cchk);
		free (stmp);
	}
	jumpdone = False;
	if (! (ret = setjmp (termenv))) {
		dojump = False;
# if		POSIX_SIGNAL
		sact.sa_handler = handler;
		sign.sa_handler = SIG_IGN;
		sigemptyset (& sact.sa_mask);
		sigemptyset (& sign.sa_mask);
		sigaddset (& sact.sa_mask, SIGHUP);
		sigaddset (& sact.sa_mask, SIGINT);
		sigaddset (& sact.sa_mask, SIGQUIT);
		sigaddset (& sact.sa_mask, SIGTERM);
		sigaddset (& sact.sa_mask, SIGPIPE);
		sigaddset (& sign.sa_mask, SIGHUP);
		sigaddset (& sign.sa_mask, SIGINT);
		sigaddset (& sign.sa_mask, SIGQUIT);
		sigaddset (& sign.sa_mask, SIGTERM);
		sigaddset (& sign.sa_mask, SIGPIPE);
		sact.sa_flags = 0;
		sign.sa_flags = 0;
		sigaction (SIGHUP, & sact, NULL);
		sigaction (SIGINT, & sact, NULL);
		sigaction (SIGQUIT, & sact, NULL);
		sigaction (SIGTERM, & sact, NULL);
		sigaction (SIGPIPE, & sign, NULL);
# else		/* POSIX_SIGNAL */
		signal (SIGHUP, handler);
		signal (SIGINT, handler);
		signal (SIGQUIT, handler);
		signal (SIGTERM, handler);
# ifdef		SIGPIPE	
		signal (SIGPIPE, SIG_IGN);
# endif		/* SIGPIPE */
# endif		/* POSIX_SIGNAL */
		for (n = 0; n < mcnt; )
			n = sendit (cfg, n, mg, mcnt, & ret, delay, expire, rds);
	}
	if (mg) {
		if (! freport)
			freport = cfg_get (cfg, NULL, CFG_FREPORT, NULL);
		fp = NULL;
		if (freport)
			if (! strcmp (freport, "-"))
				fp = stdout;
			else if (! (fp = fopen (freport, "w"))) {
				fprintf (stderr, "Unable to open %s for final report, sending it to stdout\n", freport);
				fp = stdout;
			}
		if (fp && (mcnt > 1))
			qsort (mg, mcnt, sizeof (message), ncompare);
		for (m = 0, onr = -1; m < mcnt; ++m) {
			if (fp && (onr != mg[m].nr)) {
				onr = mg[m].nr;
				succ = True;
				for (n = m; (n < mcnt) && (mg[n].nr == onr); ++n)
					if (! (mg[n].st.success)) {
						succ = False;
						break;
					}
				ptr = NULL;
				if (! succ) {
					switch (mg[n].st.reason) {
					case NotTried:
						ptr = "unable to connect";
						break;
					case CantDial:
						ptr = "could not dial service provider";
						break;
					case NotSend:
						ptr = "unable to send";
						break;
					case CantSend:
						ptr = "could not transmit the message";
						break;
					}
				}
				fprintf (fp, "%c%d %s: %s %s\n", 
					 (succ ? '+' : '-'), mg[m].nr,
					 (mg[m].alias ? mg[m].alias : (mg[m].pid ? mg[m].pid : "")),
					 (mg[m].st.rmsg ? mg[m].st.rmsg : ""),
					 (ptr ? ptr : ""));
			}
			if (mg[m].callid)
				free (mg[m].callid);
			if (mg[m].alias)
				free (mg[m].alias);
			if (mg[m].pid)
				free (mg[m].pid);
			if (mg[m].service)
				free (mg[m].service);
			if (mg[m].msg)
				sfree (mg[m].msg);
			if (mg[m].st.rmsg)
				free (mg[m].st.rmsg);
		}
		free (mg);
		if (fp && (fp != stdout))
			fclose (fp);
	}
	cfg_end (cfg);
	return ret;
}
/*}}}*/