sms_modem.c

使用TAP的蜂窝型GSM手机短消息服务中心

		t.c_cflag |= PARODD; 		/* set parity to odd	*/
		break;
	case 'N':
		break;				/* No parity DEFAULT	*/
	default:
		lprintf(LOG_ERROR, "MODEM: Parity must be either E,O or N\n");

		close(modem);
		return -1; 
	}


	/* ---------------------------- */
	/* Set stop bits 1 or 2		*/
	/* ---------------------------- */
	
	switch (stop)
	{
	case '2':
		t.c_cflag |= CSTOPB;		/* 2 Stop bits		*/
		break;
	case '1':				/* 1 Stop bits DEFAULT	*/ 
		break;
	default:
		lprintf(LOG_ERROR, "MODEM: Stop bits must be either 1 or 2\n");

		close(modem);
		return -1; 
	}


	/* ---------------------------- */
	/* Set flow control		*/
	/* Hardware or Software		*/
	/* ---------------------------- */

	switch (flow)
	{
#if defined(LINUX)
	case 'H':
		t.c_cflag |= CRTSCTS;		/* Hardware Flow	*/
		             			/* control		*/
		break;
#endif
	case 'S':
		t.c_iflag |= IXON |		/* Xon/Xoff Flow	*/
		             IXOFF |		/* control		*/
		             IXANY;
		break;
	default:
#if !defined(LINUX)
		lprintf(LOG_ERROR, "MODEM: Flow control must be S for this platform\n");
#else
		lprintf(LOG_ERROR, "MODEM: Flow control must be either H or S for this platform\n");
#endif
		close(modem);
		return -1; 
	}


	/* ---------------------------- */
	/* Set baud rate		*/
	/* Convert from numeric to 	*/
	/* defines set in termios	*/
	/* ---------------------------- */

	if (baud >= 38400)
	{	t_baud = B38400;
	}
	else if (baud >= 19200)
	{	t_baud = B19200;
	}
	else if (baud >= 9600)
	{	t_baud = B9600;
	}
	else if (baud >= 4800)
	{	t_baud = B4800;
	}
	else if (baud >= 2400)
	{	t_baud = B2400;
	}
	else if (baud >= 1200)
	{	t_baud = B1200;
	}
	else
	{	t_baud = B300;
	}

 	if (cfsetispeed(&t, t_baud) == -1) 	/* Set Input Baud rate 	*/
	{
		lprintf(LOG_WARNING, "MODEM: Failed Trying to set Input baud to %ld\n", baud);

		close(modem);
		return -1;
	}

	if (cfsetospeed(&t, t_baud) == -1) 	/* Set output Baud rate	*/
	{
		lprintf(LOG_WARNING, "MODEM: Failed Trying to set Output baud to %ld\n", baud);

		close(modem);
		return -1;		
	}

	/* ---------------------------- */
	/* Apply changes to modem	*/
	/* device			*/
	/* ---------------------------- */

	if (tcflush(modem, TCIOFLUSH) == -1) 
	{	lprintf(LOG_WARNING, "MODEM: Failed tcflush()\n");

		close(modem);
		return -1;
	}

	if (tcsetattr(modem,TCSANOW, &t) == -1) 
	{	lprintf(LOG_WARNING, "MODEM: Failed tcsetattr()\n");

		close(modem);
		return -1;
	}

	/* ---------------------------- */
	/* Reset mode to blocking	*/
	/* ---------------------------- */

	fcntl_clear(modem, O_NONBLOCK);

	if (toggle_DTR(modem, MDM_dtr_sleep))
	{	close(modem);
		return -1;
	}

	modem_status = MODEM_OPEN;
	return modem;
}


/* -------------------------------------------------------------------- */
/* Send AT string. Check if result contains AT.				*/
/* If command is echoed then set modem_echo flag.			*/
/* -------------------------------------------------------------------- */
int test_modem_echo(int modem)
{
	char	buf[MAX_BUFSIZE],
		str[MAX_BUFSIZE];


	sms_strcpy(str, command_prefix);
	sms_strcat(str, command_suffix);

	if (twrite(modem, str, sms_strlen(str), MDM_write_timeout))
	{	return(-1);
	}

	if (expstr(modem, buf, response_prefix, MAX_BUFSIZE, MDM_echo_timeout))
	{	return(-1);
	}

	if (strncmp(buf, str, sms_strlen(str)) == 0)
	{
		modem_echo = TRUE;
		lprintf(LOG_VERBOSE, "MODEM: Modem echo is set to ON\n");
	} 
	else
	{	modem_echo = FALSE;
		lprintf(LOG_VERBOSE, "MODEM: Modem echo is set to OFF\n");
	}

	if (expstr(modem, buf, response_suffix, MAX_BUFSIZE, MDM_echo_timeout))
	{	return(-1);
	}

	if (strncmp(buf, "OK", sms_strlen("OK")))
	{	return(-1);
	}

	return 0;
}
/* -------------------------------------------------------------------- */
/* Send ATE0 string to set local echo to off.				*/
/* -------------------------------------------------------------------- */
int set_local_echo(int modem)
{
	char	str[MAX_BUFSIZE];
	int	res;

	sms_usleep(test_guard_time);

	if (twrite(modem, "\r", sms_strlen("\r"), MDM_write_timeout))
	{	return(-1);
	}

	sms_usleep(test_guard_time);

	if (twrite(modem, "\r", sms_strlen("\r"), MDM_write_timeout))
	{	return(-1);
	}

	sms_usleep(test_guard_time);

	sms_strcpy(str, command_prefix);
	sms_strcat(str, set_local_echo_off);
	sms_strcat(str, command_suffix);

	if (twrite(modem, str, sms_strlen(str), MDM_write_timeout))
	{	return(-1);
	}

	if ((res = MDM_response(modem, MDM_response_timeout)) != MDM_OK)
	{	return(-1);
	}

	lprintf(LOG_VERBOSE, "MODEM: Setting Local Modem Echo to OFF\n");

	if (test_modem_echo(modem))
	{	return(-1);
	}
	
	if (modem_echo)
	{	return(-1);
	}

	return 0;
}

/* -------------------------------------------------------------------- */
/* -------------------------------------------------------------------- */
int MDM_send_hangup(int modem)
{
	char 	str[MAX_BUFSIZE],
		*ptr;
	int	res, 
		retry,
		hangup_status;


	hangup_status = FALSE;
	for (retry = soft_hangup_retries; retry > 0; retry--)
	{
		tcflush(modem, TCIOFLUSH);	/* Flush all data 	*/

		sms_usleep(guard_time);		/* Sleep for gaurd_time	*/
						/* before transmitting	*/
						/* any data		*/

		for(ptr = attention_command; *ptr ;ptr++)
		{
			str[0] = *ptr;
			str[1] = '\0';
		
			if (twrite(modem, str, sms_strlen(str), MDM_write_timeout))
			{	break;
			}
	
			if (ptr[1] != '\0')
			{	sms_usleep(esc_time);
			}
		}

		if (*ptr)
		{	lprintf(LOG_WARNING, "MODEM: Failed to issue attention command - %s\n", attention_command); 
			break;
		}

		sms_usleep(guard_time);		/* Sleep for gaurd_time	*/
						/* before transmitting	*/
						/* any data		*/
	


		res = MDM_response(modem, MDM_hangup_timeout);
	 	if (res != MDM_OK)
		{	lprintf(LOG_WARNING, "MODEM: Expecting OK response - %s\n", get_response(res)); 
		}


		sms_usleep(guard_time);		/* Sleep for gaurd_time	*/


		sms_strcpy(str, command_prefix);
		sms_strcat(str, command_suffix);
	
		twrite(modem, str, sms_strlen(str), MDM_write_timeout);
		res = MDM_response(modem, MDM_hangup_timeout);
	 	if (res != MDM_OK)
		{	lprintf(LOG_WARNING, "MODEM: Expecting OK response - %s\n", get_response(res)); 
		}

		sms_strcpy(str, command_prefix);
		sms_strcat(str, hangup_command);
		sms_strcat(str, command_suffix);

		twrite(modem, str, sms_strlen(str), MDM_write_timeout);
		res = MDM_response(modem, MDM_hangup_timeout);
	 	if (res != MDM_OK)
		{	if ((res == MDM_NO_CARRIER) ||
			    (res == MDM_DISCONNECTED))
			{
				hangup_status = TRUE;
				break;
			}

			lprintf(LOG_WARNING, "MODEM: Expecting OK response - %s\n", get_response(res)); 
		}
		else
		{	hangup_status = TRUE;
			break;
		}
	}

	return hangup_status;
}


/* -------------------------------------------------------------------- */
/* -------------------------------------------------------------------- */
int toggle_DTR(int modem, int sleep_int)
{
struct 	termios 
	t;
speed_t	ibaud,
	obaud;


	if (tcgetattr(modem, &t) == -1)
	{	lprintf(LOG_WARNING, "MODEM: Failed tcgetattr()\n");

		close(modem);
		return -1;
	}

	if (((ibaud = cfgetispeed(&t)) == -1) ||
	    ((obaud = cfgetospeed(&t)) == -1))
	{
		lprintf(LOG_WARNING, "MODEM: Failed cfgetspeed()\n");
		return -1;
	}

	if ((cfsetospeed(&t, B0) == -1) || 	/* Hangup as B0 causes	*/
	    (cfsetispeed(&t, B0) == -1)) 	/* DTR to be lowered	*/
	{					
		lprintf(LOG_WARNING, "MODEM: Failed cfsetspeed() - B0 HANGUP\n");
		return -1;
	}

	if (tcsetattr(modem,TCSANOW, &t) == -1) 
	{	lprintf(LOG_WARNING, "MODEM: Failed tcsetattr() - B0 HANGUP\n");
		return -1;
	}

	sleep(sleep_int);			/* Allow things to 	*/
						/* Settle down DTR may	*/
						/* need to be left	*/
						/* lowered for a period	*/
						/* of time		*/


	if ((cfsetospeed(&t, obaud) == -1) ||
	    (cfsetispeed(&t, ibaud) == -1))
	{					
		lprintf(LOG_WARNING, "MODEM: Failed cfsetspeed()\n");
		return -1;
	}

	if (tcsetattr(modem,TCSANOW, &t) == -1) 
	{
#if 0
		lprintf(LOG_WARNING, "MODEM: Failed tcsetattr() - setting speed\n");
		return -1;
#endif
	}

	return 0;
}

/* -------------------------------------------------------------------- */
/* -------------------------------------------------------------------- */
void MDM_hangup(int modem)
{
	if (modem_status == MODEM_CLOSED)
	{	return;
	}

	MDM_send_hangup(modem);
	toggle_DTR(modem, MDM_dtr_sleep);

#if 0
	lprintf(LOG_VERBOSE, "MODEM: Returning Terminal to original settings\n");

	if (tcsetattr(modem, TCSANOW, &t_orig) == -1)
	{
						/* Failed to return 	*/
						/* to original terminal	*/
						/* settings		*/

		lprintf(LOG_WARNING, "MODEM: Failed tcsetattr() - Trying to return modem device to original settting\n");
	}

#endif

	close(modem);
	modem_status = MODEM_CLOSED;

	lprintf(LOG_VERBOSE, "MODEM: Hangup Complete\n");

	resource_unlock(modem_lockfile);	/* Remove lock file	*/
						/* on this device	*/
}

/* -------------------------------------------------------------------- */
/* -------------------------------------------------------------------- */
int MDM_dial(char *number, char data, char parity, char stop, long baud) 
{
	int 	modem,
		res;
	char 	str[MAX_BUFSIZE],
		fname[MAX_BUFSIZE];


	sms_strcpy(fname, MODEMDIR);
	sms_strcat(fname, "/sms_modem");

	if (read_resource_file(fname, resource_list, TRUE) != RESOURCE_FILE_OK)
	{	lprintf(LOG_ERROR, "MODEM: Unrecoverable Failure Parsing modem file %s\n", fname); 
		exit(-1);
	}



	sms_strcpy(modem_file, device_dir);
	sms_strcat(modem_file, device);


	sms_strcpy(modem_lockfile, lock_dir);

	if (modem_lockfile[sms_strlen(modem_lockfile)] != '/')
	{	sms_strcat(modem_lockfile, "/");
	}

	sms_strcat(modem_lockfile, lock_prefix);


#if 0
/* SOLARIS Lockfile syntax must add the following. */
	
{ RESOURCE_STRING,  "MDM_lock_platform", 	0, 0, NULL, 0, "TRADITIONAL",   0, 	  &lock_platform  	},
{ RESOURCE_STRING,  "MDM_lock_format", 		0, 0, NULL, 0, "TRADITIONAL",   0, 	  &lock_format  	},


#include <sys/types.h>
#include <sys/stat.h>
#include <sys/mkdev.h>

static 	char 	*lock_platform,
		*lock_format;


	struct stat stat_buf;


	if (stat(modem_file, &stat_buf) == -1)
	{	lprintf(LOG_ERROR, "MODEM: stat() Failed\n"); 
		exit(-1);
	}

	if (strcmp(lock_platform, "SOLARIS") == 0)
	{
		sprintf(&modem_lockfile[sms_strlen(modem_lockfile)],"%03u.%03u.%03u",
		        major(stat_buf.st_dev),
		        stat_buf.st_rdev >> 18,
		        minor(stat_buf.st_rdev));
	}
	else
	{	if (strcmp(MDM_lock_platform, "TRADITIONAL") != 0)
		{	lprintf(LOG_WARNING, "MODEM: MDM_lock_platform invalid using 'TRADITIONAL'\n"); 
		}

		sms_strcat(modem_lockfile, device);
	}
#else
	sms_strcat(modem_lockfile, device);
#endif


	if ((strcmp(flow_control, "Software") != 0) &&
	    (strcmp(flow_control, "Hardware") != 0))
	{
		lprintf(LOG_ERROR, "MODEM: MDM_flow_control must be either 'Software' or 'Hardware'\n"); 
		exit(-1);
	}

	MDM_obtain_lock(device);	/* May Block until lock		*/
					/* obtained. This is dependant 	*/
					/* on 'lock_action' set to	*/
					/* BLOCK or NO_BLOCK		*/


	modem = MDM_init(modem_file, data, parity, stop, flow_control[0], baud);
	if (modem < 0)
	{	lprintf(LOG_ERROR, "MODEM: MDM_init() Failed\n"); 
		exit(-1);
	}

	if (set_local_echo(modem) == -1)
	{	lprintf(LOG_ERROR, "MODEM: Setting Local echo Failed\n"); 
		exit(-1);
	}
	
	sms_strcpy(str, command_prefix);
	sms_strcat(str, init_command);
	sms_strcat(str, command_suffix);

	lprintf(LOG_VERBOSE, "MODEM: Sending Initialization string %s to modem\n", str); 

	if (MDM_send(modem, str) != 0)
	{	lprintf(LOG_VERBOSE, "MODEM: Sending Initialization string\n"); 
		exit(-1);
	}

	lprintf(LOG_VERBOSE, "MODEM: Waiting for Initialization to complete...\n"); 

	if ((res = MDM_response(modem, MDM_response_timeout)) != MDM_OK)
	{	lprintf(LOG_VERBOSE, "MODEM: Expecting OK response - %s\n", get_response(res)); 
		exit(-1);
	}

	lprintf(LOG_VERBOSE, "MODEM: Initialization complete\n"); 

	lprintf(LOG_VERBOSE, "MODEM: Dialing %s\n", number); 

	sms_strcpy(str, command_prefix);
	sms_strcat(str, dial_command);
	sms_strcat(str, number_prefix);
	sms_strcat(str, number);
	sms_strcat(str, command_suffix);

	lprintf(LOG_VERBOSE, "MODEM: Sending dial string %s to modem\n", str); 

	if (MDM_send(modem, str) != 0)
	{	lprintf(LOG_ERROR, "MODEM: Sending dial string\n");
		exit(-1);
	}

	lprintf(LOG_VERBOSE, "MODEM: Waiting for Connection...\n");

	if ((res = MDM_response(modem, MDM_connect_timeout)) != MDM_CONNECT)
	{	lprintf(LOG_VERBOSE, "MODEM: Expecting CONNECT response - %s\n", get_response(res)); 
		exit(-1);
	}

	lprintf(LOG_VERBOSE, "MODEM: Connection Established.\n");
	return modem;
}