Attachment #109717 for bug #166205

View | Details | Raw Unified | Return to bug 166205
Collapse All | Expand All

Lines 57-62 Link Here

(-)/opt/tmp/portage/net-dialup/mgetty-1.1.35-r2/work/mgetty-1.1.35/conf_mg.c (+1 lines)
57	{ "switchbd", {FAX_RECV_SWITCHBD}, CT_INT, C_PRESET },	57	{ "switchbd", {FAX_RECV_SWITCHBD}, CT_INT, C_PRESET },
58	{ "direct", {FALSE}, CT_BOOL, C_PRESET },	58	{ "direct", {FALSE}, CT_BOOL, C_PRESET },
59	{ "blocking", {FALSE}, CT_BOOL, C_PRESET },	59	{ "blocking", {FALSE}, CT_BOOL, C_PRESET },
		60	{ "nodevsleep", FALSE, CT_BOOL, C_PRESET },
60		61
61	{ "port-owner", {(p_int) DEVICE_OWNER}, CT_STRING, C_PRESET },	62	{ "port-owner", {(p_int) DEVICE_OWNER}, CT_STRING, C_PRESET },
62	#ifdef DEVICE_GROUP	63	#ifdef DEVICE_GROUP

Lines 10-15 Link Here

(-)/opt/tmp/portage/net-dialup/mgetty-1.1.35-r2/work/mgetty-1.1.35/conf_mg.h (+1 lines)
10	switchbd, /* speed switch for fax rec.*/	10	switchbd, /* speed switch for fax rec.*/
11	direct_line, /* direct lines */	11	direct_line, /* direct lines */
12	blocking, /* do blocking open */	12	blocking, /* do blocking open */
		13	nodev_sleep, /* sleep when open() returns ENODEV */
13		14
14	port_owner, /* "uucp" */	15	port_owner, /* "uucp" */
15	port_group, /* "modem" */	16	port_group, /* "modem" */




		      case CT_STRING:
			if ( ( cp->d.p = malloc( strlen( line ) +1 ) ) == NULL )
				errflag ++;
 			else {
 				char *linep = line;
 				int empty = 1;
 				strcpy( cp->d.p, line );
 				while ( *linep ) {
 					if ( *linep != '\r' && *linep != '\n' && !isspace(*linep)) {
 						empty = 0;
 						break;
 					}
 					linep ++;
 				}
 				if (empty) {
 					*(char *)cp->d.p = 0;
 					cp->flags = C_EMPTY;
 				}
			     }
			break;
		      case CT_CHAT:
			if ( ( cp->d.p = conf_get_chat( line ) ) == NULL )

Lines 24-29 Link Here

(-)/opt/tmp/portage/net-dialup/mgetty-1.1.35-r2/work/mgetty-1.1.35/logname.c (-1 / +271 lines)
24	#include <string.h>	24	#include <string.h>
25	#include <signal.h>	25	#include <signal.h>
26	#include <sys/types.h>	26	#include <sys/types.h>
		27	#ifdef AUTO_HOTSYNC
		28	#include <sys/socket.h>
		29	#endif
27	#include <time.h>	30	#include <time.h>
28	#include <ctype.h>	31	#include <ctype.h>
29	#ifndef sunos4	32	#ifndef sunos4
Lines 258-263 Link Here
258	timeouts++;	261	timeouts++;
259	}	262	}
260		263
		264	#ifdef AUTO_HOTSYNC
		265	#define BUF_SIZE 8192
		266	#define STDOUT 0
		267	static int child_exited = 0;
		268	int mg_dump;
		269
		270	static void sig_child(int signal)
		271	{
		272	child_exited = 1;
		273	}
		274
		275	int read_to_ring(int fromh, char buf, char tail_ptr, char head)
		276	{
		277	char tail = tail_ptr;
		278	int ret = 1;
		279
		280	if ((tail + 1 - buf) % BUF_SIZE == (head - buf) % BUF_SIZE) {
		281	/* buffer full */
		282	ret = 0;
		283	}
		284	else {
		285	if ( tail < head ) {
		286	ret = read(fromh, tail, head - tail - 1);
		287	}
		288	else {
		289	if ( head == buf ) {
		290	ret = read(fromh, tail, buf + BUF_SIZE - tail - 1);
		291	}
		292	else {
		293	ret = read(fromh, tail, buf + BUF_SIZE - tail);
		294	if ( ret == buf + BUF_SIZE - tail ) {
		295	/* read more */
		296	struct timeval tv;
		297	fd_set fds;
		298	int got;
		299
		300	FD_ZERO(&fds);
		301	FD_SET(fromh, &fds);
		302	tv.tv_sec = 0;
		303	tv.tv_usec = 0;
		304	got = select(fromh + 1, &fds, NULL, NULL, &tv);
		305	if ( got < 0 ) {
		306	lprintf(L_FATAL, "read_to_ring: select error %d, %s",
		307	errno, strerror(errno));
		308	exit(errno);
		309	}
		310	else if (got > 0) {
		311	got = read(fromh, buf, head - buf - 1);
		312	if ( got < 0 ) {
		313	ret = got;
		314	}
		315	else {
		316	FD_ZERO(&fds);
		317	FD_SET(fromh, &fds);
		318	tv.tv_sec = 0;
		319	tv.tv_usec = 0;
		320	if ( got == head - buf -1 &&
		321	select(fromh + 1, &fds, NULL, NULL,
		322	&tv) > 0) {
		323
		324	lprintf(L_WARN, "read_to_ring: "
		325	"buffer full reise BUF_SIZE "
		326	"& recompile mgetty");
		327	}
328	ret += got;
329	}
330	}
331	}
332	}
333	}
334	if (ret < 0 ) {
335	ret = -errno;
336	}
337	else {
338	tail = buf + (tail - buf + ret) % BUF_SIZE;
339	}
340	}
341
342	*tail_ptr = tail;
343
344	return ret;
345	}
346
347	int write_from_ring(int tofh, char buf, char tail, char **head_ptr)
348	{
349	char head = head_ptr;
350	int ret = 1;
351
352	if ( head == tail ) {
353	/* buffer empty */
354	ret = 0;
355	}
356	else {
357	if ( tail > head ) {
358	ret = write(tofh, head, tail - head);
359	}
360	else {
361	ret = write(tofh, head, buf + BUF_SIZE - head);
362	if ( ret == buf + BUF_SIZE - head ) {
363	/* write more? */
364	struct timeval tv;
365	fd_set fds;
366	int got;
367
368	FD_ZERO(&fds);
369	FD_SET(tofh, &fds);
370	tv.tv_sec = 0;
371	tv.tv_usec = 0;
372	got = select(tofh + 1, NULL, &fds, NULL, &tv);
373	if ( got < 0 ) {
374	lprintf(L_FATAL, "write_from_ring: select error %d, %s",
375	errno, strerror(errno));
376	exit(errno);
377	}
378	else if ( got > 0 ) {
379	got = write(tofh, buf, tail - head);
380	if ( got < 0 ) {
381	ret = got;
382	}
383	else {
384	ret += got;
385	}
386	}
387	}
388	}
389	if ( ret < 0 ) {
390	ret = -errno;
391	}
392	else {
393	head = buf + (head + ret - buf) % BUF_SIZE;
394	}
395	}
396
397	*head_ptr = head;
398	return ret;
399	}
400	#endif
401
261	/* getlogname()	402	/* getlogname()
262	*	403	*
263	* read the login name into "char buf[]", maximum length "maxsize".	404	* read the login name into "char buf[]", maximum length "maxsize".
Lines 282-287 Link Here
282	static int ppp_level = 0, ppp_escaped = 0;	423	static int ppp_level = 0, ppp_escaped = 0;
283	char ppp_ch;	424	char ppp_ch;
284	#endif	425	#endif
		426	#ifdef AUTO_HOTSYNC
		427	int pipefd[2];
		428	int pid;
		429	int sel;
		430	struct timeval tv;
		431	fd_set fds, pipefds;
		432	char pipebuf[BUF_SIZE] = {HOTSYNC};
		433	char devbuf[BUF_SIZE];
		434	char *pipe_tail = pipebuf + 1;
		435	char *pipe_head = pipebuf;
		436	char *dev_tail = devbuf;
		437	char *dev_head = devbuf;
		438	int devr = 0, devw = 0, piper = 0, pipew = 0;
		439	#endif
285		440
286	/* read character by character! */	441	/* read character by character! */
287	tio_save = *tio;	442	tio_save = *tio;
Lines 315-321 Link Here
315	newlogin_noemsi:	470	newlogin_noemsi:
316	#endif	471	#endif
317		472
318	printf( "\r\n%s", final_prompt );	473	if (*final_prompt)
		474	printf( "%s", final_prompt );
319		475
320	if ( ferror( stdin ) )	476	if ( ferror( stdin ) )
321	{	477	{
Lines 427-432 Link Here
427	ppp_escaped = 0;	583	ppp_escaped = 0;
428	}	584	}
429	#endif	585	#endif
		586	#ifdef AUTO_HOTSYNC
		587	if (ch == (char) HOTSYNC) {
		588	strcpy(buf, "/HotSync/");
		589	i = 9; /* Length of magic word /HotSync/ */
		590	ch = '\n';
		591
		592	if (socketpair(PF_UNIX, SOCK_STREAM, 0, pipefd) < 0 ) {
		593	lprintf(L_FATAL, "getlogname: pipe error %d, %s",
		594	errno, strerror(errno));
		595	return -1;
		596	}
		597
		598	signal(SIGCHLD, sig_child);
		599
		600	pid = fork();
		601
		602	if ( pid < 0 ) {
		603	lprintf( L_FATAL, "getlogname: unable to fork %d, %s",
		604	errno, strerror(errno));
		605	return -1;
		606	}
		607	else if (pid > 0) {
		608	/* parent */
		609	do {
		610	tv.tv_usec = 0;
		611	tv.tv_sec = 10;
		612	FD_ZERO(&fds);
		613	FD_ZERO(&pipefds);
		614
		615	FD_SET(pipefd[1], &pipefds);
		616	FD_SET(STDOUT, &pipefds);
		617
		618	FD_SET(STDIN, &fds);
		619	FD_SET(pipefd[1], &fds);
		620	sel = select(pipefd[1] + 1, &fds, &pipefds, NULL, &tv);
		621	if ( sel > 0 ) {
		622
		623	/* Checking read descriptors in fds */
		624	if ( FD_ISSET(STDIN, &fds) ) {
		625	sel = read_to_ring(STDIN, pipebuf, &pipe_tail, pipe_head);
		626	devr += sel;
		627	if ( sel == 0 ) {
		628	lprintf(L_WARN, "getlogname: no space in pipebuf");
		629	}
		630	else if ( sel < 0 ) {
		631	lprintf(L_FATAL,
		632	"getlogname: stdin read error %d, %s",
		633	-sel, strerror(-sel));
		634	exit(-sel);
		635	}
		636	}
		637	if ( FD_ISSET(pipefd[1], &fds) ) {
		638	sel = read_to_ring(pipefd[1], devbuf, &dev_tail, dev_head);
		639	piper += sel;
		640	if ( sel == 0 ) {
		641	lprintf(L_WARN, "getlogname: no space in devbuf");
		642	}
		643	else if ( sel < 0 ) {
		644	lprintf(L_FATAL,
		645	"getlogname: pipe read error %d, %s",
		646	-sel, strerror(-sel));
		647	exit(-sel);
		648	}
		649	}
650
651	/* Checking write descriptors in pipefds */
652	if ( FD_ISSET(pipefd[1], &pipefds) ) {
653	sel = write_from_ring(pipefd[1], pipebuf, pipe_tail, &pipe_head);
654	pipew += sel;
655	if ( sel == 0 ) {
656	lprintf(L_NOISE, "getlogname: pipe buffer empty");
657	}
658	else if ( sel < 0 ) {
659	lprintf(L_FATAL,
660	"getlogname: pipe write error %d, %s",
661	-sel, strerror(-sel));
662	exit(-sel);
663	}
664	}
665	if ( FD_ISSET(STDOUT, &pipefds) ) {
666	sel = write_from_ring(STDOUT, devbuf, dev_tail, &dev_head);
667	devw += sel;
668	if ( sel == 0 ) {
669	lprintf(L_NOISE, "getlogname: stdout buffer empty");
670	}
671	else if ( sel < 0 ) {
672	lprintf(L_FATAL,
673	"getlogname: stdout write error %d, %s",
674	-sel, strerror(-sel));
675	exit(-sel);
676	}
677	}
678	}
679	else if ( sel < 0 ) {
680	lprintf(L_FATAL, "getlogname: select error %d, %s",
681	errno, strerror(errno));
682	exit(errno);
683	}
684	else {
685	lprintf(L_WARN, "getlogname: select timeout");
686	}
687	} while ( !child_exited );
688
689	lprintf(L_AUDIT, "getlogname: child exited, device r/w: %d/%d, pipe r/w: %d/%d",
690	devr, devw, piper, pipew);
691
692	exit(0);
693	}
694
695	/* child (pid == 0) */
696	dup2(pipefd[0], STDIN);
697	return 0;
698	}
699	#endif
430		700
431	#ifdef JANUS	701	#ifdef JANUS
432	/* ignore ^X as first character, some JANUS programs send it first	702	/* ignore ^X as first character, some JANUS programs send it first




 * getting the line as controlling tty
 */

extern int mg_dump;

int mg_open_device _P3 ( (devname, blocking, nodev_sleep),
		         char * devname, boolean blocking,
			 boolean nodev_sleep)
{
    int fd;

    if ( ! blocking )
    {
    again2:
	fd = open(devname, O_RDWR | O_NDELAY | O_NOCTTY );
	if ( fd < 0 )
	{
		if (nodev_sleep &&
		    (errno == ENODEV || errno == ENOENT || errno == ENXIO))
		{
			lprintf( L_NOISE, "mod: no device %s, errno %d, sleeping", devname, errno);
			sleep(5);
			goto again2;
		}
		else
		{
			lprintf( L_FATAL, "mod: cannot open line %s", devname );
			return ERROR;
		}
	}

	/* unset O_NDELAY (otherwise waiting for characters */

	    
	if ( fd < 0)
	{
	    if ( errno == EAGAIN || ( nodev_sleep
		 && ( errno == ENODEV || errno == ENOENT || errno == ENXIO )))
	    {
		    lprintf(L_NOISE, "mod: no device %s, errno %d, sleeping", devname, errno);
		    sleep(5);
		    goto again;
	    }
	    
	    lprintf( L_FATAL, "mod: cannot open line %s", devname );
	    return ERROR;


    (void) close(1);
    (void) close(2);

    if (dup(0) != 1)
    {
	lprintf( L_FATAL, "mod: cannot dup to stdout"); return ERROR;

 * if first init fails, try again: on Linux and SunOS, the port isn't
 * able anymore after carrier drop, but after reopening it, it is.
 */
int mg_get_device _P6( (devname, blocking_open,
			toggle_dtr, toggle_dtr_waittime, portspeed, nodev_sleep ),
		      
		        char * devname, boolean blocking_open,
		        boolean toggle_dtr, int toggle_dtr_waittime,
		        unsigned int portspeed, boolean nodev_sleep)
{
    boolean first_try = TRUE;
    int rs_lines;

    
    /* open device, make it stdin/out/err */
try_again:
    if ( mg_open_device( devname, blocking_open, nodev_sleep ) == ERROR )
    {
	lprintf( L_FATAL, "open device %s failed", devname );
	return ERROR;




    lprintf( L_MESG, "Got callback signal from pid=%d!", pid );

    /* reopen device */
    if ( mg_open_device( devname, FALSE, FALSE ) == ERROR )
    {
	lprintf( L_FATAL, "stsc: can't reopen device" );
	exit(0);

    /* open + initialize device (mg_m_init.c) */
    if ( mg_get_device( devname, c_bool(blocking),
		        c_bool(toggle_dtr), c_int(toggle_dtr_waittime),
		        c_int(speed),
			c_bool(nodev_sleep)) == ERROR )
    {
	lprintf( L_FATAL, "cannot get terminal line dev=%s, exiting", Device);
	exit(30);
    }
    
    /* drain input - make sure there are no leftover "NO CARRIER"s
     * or "ERROR"s lying around from some previous dial-out
     */
    clean_line( STDIN, 1);

    /* do modem initialization, normal stuff first, then fax
     */
    if ( c_bool(direct_line) )
        Connect = "DIRECT";		/* for "\I" in issue/prompt */
    else
    {
	/* drain input - make sure there are no leftover "NO CARRIER"s
	 * or "ERROR"s lying around from some previous dial-out
	 */
	clean_line( STDIN, 1);

	/* initialize data part */
	if ( mg_init_data( STDIN, c_chat(init_chat), c_bool(need_dsr),
	                          c_chat(force_init_chat) ) == FAIL )

    /* wait .3s for line to clear (some modems send a \n after "OK",
       this may confuse the "call-chat"-routines) */

    if ( !c_bool(direct_line) )
	    clean_line( STDIN, 3);

    /* remove locks, so any other process can dial-out. When waiting
       for "RING" we check for foreign lockfiles, if there are any, we

       be sent by the modem, on a non-MNP-Modem the MNP-request
       string sent by a calling MNP-Modem is discarded here, too) */
    
    if (!c_bool(direct_line))
	    clean_line( STDIN, 3);

    tio_get( STDIN, &tio );
    /* honor carrier now: terminate if modem hangs up prematurely

	NeXT_repair_line(STDIN);
#endif
	
	/* fputc('\r', stdout); */	/* just in case */
	
	if (c_isset(issue_file))
	{




#define PPP_LCP_LOW	0x21	/* LCP protocol - low byte */
#define PPP_UNESCAPE(c)	((c) ^ 0x20) /* un-escape character */

/* defines for Palm HotSync */
#define HOTSYNC		    0x90

/* stuff in logfile.c */

#define L_FATAL 0

			       boolean fax_only, int fax_max_speed ));
int 	mg_init_voice _PROTO(( int fd ));
void	faxpoll_server_init _PROTO(( int fd, char * fax_server_file ));
int	mg_open_device _PROTO(( char * devname, boolean blocking, boolean nodev_sleep ));
int	mg_init_device _PROTO(( int fd, boolean toggle_dtr,
			        int toggle_dtr_waittime,
			        unsigned int portspeed ));
int	mg_get_device _PROTO(( char * devname, boolean blocking,
			       boolean toggle_dtr, int toggle_dtr_waittime,
			       unsigned int portspeed, boolean nodev_sleep ));
int	mg_get_ctty _PROTO(( int fd, char * devname ));
int	mg_drop_ctty _PROTO(( int fd ));


Return to bug 166205

Lines 169-175 Link Here

(-)/opt/tmp/portage/net-dialup/mgetty-1.1.35-r2/work/mgetty-1.1.35/mgetty.c (-10 / +13 lines)
169	lprintf( L_MESG, "Got callback signal from pid=%d!", pid );	169	lprintf( L_MESG, "Got callback signal from pid=%d!", pid );
170		170
171	/* reopen device */	171	/* reopen device */
172	if ( mg_open_device( devname, FALSE ) == ERROR )	172	if ( mg_open_device( devname, FALSE, FALSE ) == ERROR )
173	{	173	{
174	lprintf( L_FATAL, "stsc: can't reopen device" );	174	lprintf( L_FATAL, "stsc: can't reopen device" );
175	exit(0);	175	exit(0);
Lines 443-465 Link Here
443	/* open + initialize device (mg_m_init.c) */	443	/* open + initialize device (mg_m_init.c) */
444	if ( mg_get_device( devname, c_bool(blocking),	444	if ( mg_get_device( devname, c_bool(blocking),
445	c_bool(toggle_dtr), c_int(toggle_dtr_waittime),	445	c_bool(toggle_dtr), c_int(toggle_dtr_waittime),
446	c_int(speed) ) == ERROR )	446	c_int(speed),
		447	c_bool(nodev_sleep)) == ERROR )
447	{	448	{
448	lprintf( L_FATAL, "cannot get terminal line dev=%s, exiting", Device);	449	lprintf( L_FATAL, "cannot get terminal line dev=%s, exiting", Device);
449	exit(30);	450	exit(30);
450	}	451	}
451		452
452	/* drain input - make sure there are no leftover "NO CARRIER"s
453	* or "ERROR"s lying around from some previous dial-out
454	*/
455	clean_line( STDIN, 1);
456
457	/* do modem initialization, normal stuff first, then fax	453	/* do modem initialization, normal stuff first, then fax
458	*/	454	*/
459	if ( c_bool(direct_line) )	455	if ( c_bool(direct_line) )
460	Connect = "DIRECT"; /* for "\I" in issue/prompt */	456	Connect = "DIRECT"; /* for "\I" in issue/prompt */
461	else	457	else
462	{	458	{
		459	/* drain input - make sure there are no leftover "NO CARRIER"s
		460	* or "ERROR"s lying around from some previous dial-out
		461	*/
		462	clean_line( STDIN, 1);
		463
463	/* initialize data part */	464	/* initialize data part */
464	if ( mg_init_data( STDIN, c_chat(init_chat), c_bool(need_dsr),	465	if ( mg_init_data( STDIN, c_chat(init_chat), c_bool(need_dsr),
465	c_chat(force_init_chat) ) == FAIL )	466	c_chat(force_init_chat) ) == FAIL )
Lines 519-525 Link Here
519	/* wait .3s for line to clear (some modems send a \n after "OK",	520	/* wait .3s for line to clear (some modems send a \n after "OK",
520	this may confuse the "call-chat"-routines) */	521	this may confuse the "call-chat"-routines) */
521		522
522	clean_line( STDIN, 3);	523	if ( !c_bool(direct_line) )
		524	clean_line( STDIN, 3);
523		525
524	/* remove locks, so any other process can dial-out. When waiting	526	/* remove locks, so any other process can dial-out. When waiting
525	for "RING" we check for foreign lockfiles, if there are any, we	527	for "RING" we check for foreign lockfiles, if there are any, we
Lines 960-966 Link Here
960	be sent by the modem, on a non-MNP-Modem the MNP-request	962	be sent by the modem, on a non-MNP-Modem the MNP-request
961	string sent by a calling MNP-Modem is discarded here, too) */	963	string sent by a calling MNP-Modem is discarded here, too) */
962		964
963	clean_line( STDIN, 3);	965	if (!c_bool(direct_line))
		966	clean_line( STDIN, 3);
964		967
965	tio_get( STDIN, &tio );	968	tio_get( STDIN, &tio );
966	/* honor carrier now: terminate if modem hangs up prematurely	969	/* honor carrier now: terminate if modem hangs up prematurely
Lines 1004-1010 Link Here
1004	NeXT_repair_line(STDIN);	1007	NeXT_repair_line(STDIN);
1005	#endif	1008	#endif
1006		1009
1007	fputc('\r', stdout); /* just in case */	1010	/* fputc('\r', stdout); / / just in case */
1008		1011
1009	if (c_isset(issue_file))	1012	if (c_isset(issue_file))
1010	{	1013	{

Lines 373-380 Link Here

(-)/opt/tmp/portage/net-dialup/mgetty-1.1.35-r2/work/mgetty-1.1.35/config.c (-2 / +16 lines)
373	case CT_STRING:	373	case CT_STRING:
374	if ( ( cp->d.p = malloc( strlen( line ) +1 ) ) == NULL )	374	if ( ( cp->d.p = malloc( strlen( line ) +1 ) ) == NULL )
375	errflag ++;	375	errflag ++;
376	else	376	else {
377	strcpy( cp->d.p, line );	377	char *linep = line;
		378	int empty = 1;
		379	strcpy( cp->d.p, line );
		380	while ( *linep ) {
		381	if ( linep != '\r' && linep != '\n' && !isspace(*linep)) {
		382	empty = 0;
		383	break;
		384	}
		385	linep ++;
		386	}
		387	if (empty) {
		388	(char )cp->d.p = 0;
		389	cp->flags = C_EMPTY;
		390	}
		391	}
378	break;	392	break;
379	case CT_CHAT:	393	case CT_CHAT:
380	if ( ( cp->d.p = conf_get_chat( line ) ) == NULL )	394	if ( ( cp->d.p = conf_get_chat( line ) ) == NULL )

Lines 240-258 Link Here

(-)/opt/tmp/portage/net-dialup/mgetty-1.1.35-r2/work/mgetty-1.1.35/mg_m_init.c (-10 / +29 lines)
240	* getting the line as controlling tty	240	* getting the line as controlling tty
241	*/	241	*/
242		242
		243	extern int mg_dump;
243		244
244	int mg_open_device _P2 ( (devname, blocking),	245	int mg_open_device _P3 ( (devname, blocking, nodev_sleep),
245	char * devname, boolean blocking )	246	char * devname, boolean blocking,
		247	boolean nodev_sleep)
246	{	248	{
247	int fd;	249	int fd;
248		250
249	if ( ! blocking )	251	if ( ! blocking )
250	{	252	{
		253	again2:
251	fd = open(devname, O_RDWR \| O_NDELAY \| O_NOCTTY );	254	fd = open(devname, O_RDWR \| O_NDELAY \| O_NOCTTY );
252	if ( fd < 0 )	255	if ( fd < 0 )
253	{	256	{
254	lprintf( L_FATAL, "mod: cannot open line %s", devname );	257	if (nodev_sleep &&
255	return ERROR;	258	(errno == ENODEV \|\| errno == ENOENT \|\| errno == ENXIO))
		259	{
		260	lprintf( L_NOISE, "mod: no device %s, errno %d, sleeping", devname, errno);
		261	sleep(5);
		262	goto again2;
		263	}
		264	else
		265	{
		266	lprintf( L_FATAL, "mod: cannot open line %s", devname );
		267	return ERROR;
		268	}
256	}	269	}
257		270
258	/* unset O_NDELAY (otherwise waiting for characters */	271	/* unset O_NDELAY (otherwise waiting for characters */
Lines 268-274 Link Here
268		281
269	if ( fd < 0)	282	if ( fd < 0)
270	{	283	{
271	if ( errno == EAGAIN ) goto again;	284	if ( errno == EAGAIN \|\| ( nodev_sleep
		285	&& ( errno == ENODEV \|\| errno == ENOENT \|\| errno == ENXIO )))
		286	{
		287	lprintf(L_NOISE, "mod: no device %s, errno %d, sleeping", devname, errno);
		288	sleep(5);
		289	goto again;
		290	}
272		291
273	lprintf( L_FATAL, "mod: cannot open line %s", devname );	292	lprintf( L_FATAL, "mod: cannot open line %s", devname );
274	return ERROR;	293	return ERROR;
Lines 295-301 Link Here
295		314
296	(void) close(1);	315	(void) close(1);
297	(void) close(2);	316	(void) close(2);
298		317
299	if (dup(0) != 1)	318	if (dup(0) != 1)
300	{	319	{
301	lprintf( L_FATAL, "mod: cannot dup to stdout"); return ERROR;	320	lprintf( L_FATAL, "mod: cannot dup to stdout"); return ERROR;
Lines 391-402 Link Here
391	* if first init fails, try again: on Linux and SunOS, the port isn't	410	* if first init fails, try again: on Linux and SunOS, the port isn't
392	* able anymore after carrier drop, but after reopening it, it is.	411	* able anymore after carrier drop, but after reopening it, it is.
393	*/	412	*/
394	int mg_get_device _P5( (devname, blocking_open,	413	int mg_get_device _P6( (devname, blocking_open,
395	toggle_dtr, toggle_dtr_waittime, portspeed ),	414	toggle_dtr, toggle_dtr_waittime, portspeed, nodev_sleep ),
396		415
397	char * devname, boolean blocking_open,	416	char * devname, boolean blocking_open,
398	boolean toggle_dtr, int toggle_dtr_waittime,	417	boolean toggle_dtr, int toggle_dtr_waittime,
399	unsigned int portspeed)	418	unsigned int portspeed, boolean nodev_sleep)
400	{	419	{
401	boolean first_try = TRUE;	420	boolean first_try = TRUE;
402	int rs_lines;	421	int rs_lines;
Lines 408-414 Link Here
408		427
409	/* open device, make it stdin/out/err */	428	/* open device, make it stdin/out/err */
410	try_again:	429	try_again:
411	if ( mg_open_device( devname, blocking_open ) == ERROR )	430	if ( mg_open_device( devname, blocking_open, nodev_sleep ) == ERROR )
412	{	431	{
413	lprintf( L_FATAL, "open device %s failed", devname );	432	lprintf( L_FATAL, "open device %s failed", devname );
414	return ERROR;	433	return ERROR;

Lines 53-58 Link Here

(-)/opt/tmp/portage/net-dialup/mgetty-1.1.35-r2/work/mgetty-1.1.35/mgetty.h (-2 / +5 lines)
53	#define PPP_LCP_LOW 0x21 /* LCP protocol - low byte */	53	#define PPP_LCP_LOW 0x21 /* LCP protocol - low byte */
54	#define PPP_UNESCAPE(c) ((c) ^ 0x20) /* un-escape character */	54	#define PPP_UNESCAPE(c) ((c) ^ 0x20) /* un-escape character */
55		55
		56	/* defines for Palm HotSync */
		57	#define HOTSYNC 0x90
		58
56	/* stuff in logfile.c */	59	/* stuff in logfile.c */
57		60
58	#define L_FATAL 0	61	#define L_FATAL 0
Lines 262-274 Link Here
262	boolean fax_only, int fax_max_speed ));	265	boolean fax_only, int fax_max_speed ));
263	int mg_init_voice _PROTO(( int fd ));	266	int mg_init_voice _PROTO(( int fd ));
264	void faxpoll_server_init _PROTO(( int fd, char * fax_server_file ));	267	void faxpoll_server_init _PROTO(( int fd, char * fax_server_file ));
265	int mg_open_device _PROTO(( char * devname, boolean blocking ));	268	int mg_open_device _PROTO(( char * devname, boolean blocking, boolean nodev_sleep ));
266	int mg_init_device _PROTO(( int fd, boolean toggle_dtr,	269	int mg_init_device _PROTO(( int fd, boolean toggle_dtr,
267	int toggle_dtr_waittime,	270	int toggle_dtr_waittime,
268	unsigned int portspeed ));	271	unsigned int portspeed ));
269	int mg_get_device _PROTO(( char * devname, boolean blocking,	272	int mg_get_device _PROTO(( char * devname, boolean blocking,
270	boolean toggle_dtr, int toggle_dtr_waittime,	273	boolean toggle_dtr, int toggle_dtr_waittime,
271	unsigned int portspeed ));	274	unsigned int portspeed, boolean nodev_sleep ));
272	int mg_get_ctty _PROTO(( int fd, char * devname ));	275	int mg_get_ctty _PROTO(( int fd, char * devname ));
273	int mg_drop_ctty _PROTO(( int fd ));	276	int mg_drop_ctty _PROTO(( int fd ));
274		277