lockdaemon.c.noinetd

用java控制短信猫发送或接受短信的源代码包以及一些实例程序

	gid_t list[ NGROUPS_MAX ];

	if( stat( LOCKDIR, &buf) )
	{
		sprintf( msg, "check_group_uucp:  Can not find Lock Directory: %s\n", LOCKDIR );
		syslog( LOG_INFO, msg );
		return( 1 );
	}
	group_count = getgroups( NGROUPS_MAX, list );
	list[ group_count ] = geteuid();

	if( user->pw_gid )
	{
		while( group_count >= 0 && buf.st_gid != list[ group_count ] )
		{
  			group_count--; 
		}
		if( buf.st_gid == list[ group_count ] )
			return 0;
		sprintf( msg, "%i %i\n", buf.st_gid, list[ group_count ] );
		syslog( LOG_INFO, msg );
		syslog( LOG_INFO, UUCP_ERROR );
		return 1;
	}
	return 0;
/*
	if( strcmp( user->pw_name, "root" ) )
	{
		while( *g->gr_mem )
		{
			if( !strcmp( *g->gr_mem, user->pw_name ) )
			{
				break;
			}
			(void) *g->gr_mem++;
		}
		if( !*g->gr_mem )
		{
			syslog( LOG_INFO, UUCP_ERROR );
			return 1;
		}
	}
*/
#endif /* USER_LOCK_DIRECTORY */
	return 0;
}

/*----------------------------------------------------------
 The following should be able to follow symbolic links.  I think the stat
 method used below will work on more systems.  This was found while looking
 for information.

 * realpath() doesn't exist on all of the systems my code has to run
   on (HP-UX 9.x, specifically)
----------------------------------------------------------
int different_from_LOCKDIR(const char* ld)
{
	char real_ld[MAXPATHLEN];
	char real_LOCKDIR[MAXPATHLEN];
	if (strncmp(ld, LOCKDIR, strlen(ld)) == 0)
		return 0;
	if (realpath(ld, real_ld) == NULL)
		return 1;
	if (realpath(LOCKDIR, real_LOCKDIR) == NULL)
		return 1;
	if (strncmp(real_ld, real_LOCKDIR, strlen(real_ld)) == 0)
		return 0;
	else
		return 1;
}
*/

/*----------------------------------------------------------
 is_device_locked

   accept:      char * filename.  The device in question including the path.
   perform:     see if one of the many possible lock files is aready there
		if there is a stale lock, remove it.
   return:      1 if the device is locked or somethings wrong.
		0 if its possible to create our own lock file.
   exceptions:  none
   comments:    check if the device is already locked
----------------------------------------------------------*/
int is_device_locked( const char *port_filename )
{
	const char *lockdirs[] = { "/etc/locks", "/usr/spool/kermit",
		"/usr/spool/locks", "/usr/spool/uucp", "/usr/spool/uucp/",
		"/usr/spool/uucp/LCK", "/var/lock", "/var/lock/modem",
		"/var/spool/lock", "/var/spool/locks", "/var/spool/uucp",
		LOCKDIR, NULL
	};
	const char *lockprefixes[] = { "LCK..", "lk..", "LK.", NULL }; 
	char *p, file[80], pid_buffer[20], message[80];
	int i = 0, j, k, fd , pid;
	struct stat buf;
	struct stat buf2;

	j = strlen( port_filename );
	p = ( char * ) port_filename+j;
	while( *( p-1 ) != '/' && j-- !=1 ) p--;

	while( lockdirs[i] )
	{
		/*
		   Look for lockfiles in all known places other than the
		   defined lock directory for this system
		   report any unexpected lockfiles.

		   Is the suspect lockdir there?
		   if it is there is it not the expected lock dir?
		*/
		if( !stat( lockdirs[i], &buf2 ) &&
			strncmp( lockdirs[i], LOCKDIR, strlen( lockdirs[i] ) ) )
		{
			j = strlen( port_filename );
			p = ( char *  ) port_filename + j;
		/*
		   SCO Unix use lowercase all the time
			taj
		*/
			while( *( p - 1 ) != '/' && j-- != 1 )
			{
#if defined ( __unixware__ )
				*p = tolower( *p );
#endif /* __unixware__ */
				p--;
			}
			k=0;
			while ( lockprefixes[k] )
			{
				/* FHS style */
				sprintf( file, "%s/%s%s", lockdirs[i],
					lockprefixes[k], p );
				if( stat( file, &buf ) == 0 )
				{
					sprintf( message, UNEXPECTED_LOCK_FILE,
						file );
					syslog( LOG_INFO, message );
					return 1;
				}

				/* UUCP style */
				stat(port_filename , &buf );
				sprintf( file, "%s/%s%03d.%03d.%03d",
					lockdirs[i],
					lockprefixes[k],
					(int) major( buf.st_dev ),
					(int) major( buf.st_rdev ),
					(int) minor( buf.st_rdev )
				);
				if( stat( file, &buf ) == 0 )
				{
					sprintf( message, UNEXPECTED_LOCK_FILE,
						file );
					syslog( LOG_INFO, message );
					return 1;
				}
				k++;
			}
		}
		i++;
	}

	/*
		OK.  We think there are no unexpect lock files for this device
		Lets see if there any stale lock files that need to be
		removed.
	*/
		 
#ifdef FHS
	/*  FHS standard locks */
	i = strlen( port_filename );
	p = ( char * ) port_filename + i;
	while( *(p-1) != '/' && i-- != 1)
	{
#if defined ( __unixware__ )
		*p = tolower( *p );
#endif /* __unixware__ */
		p--;
	}
	sprintf( file, "%s/%s%s", LOCKDIR, LOCKFILEPREFIX, p );
#else 
	/*  UUCP standard locks */
	if ( stat( port_filename, &buf ) != 0 )
	{
		syslog( LOG_INFO, "RXTX is_device_locked() could not find device.\n" );
		sprintf( message, "Filename is : %s \n", port_filename );
		syslog( LOG_INFO, message );
		sprintf( message, "Filename is : %s \n", port_filename );
		syslog( LOG_INFO, message );
		return 1;
	}
	sprintf( file, "%s/LK.%03d.%03d.%03d",
		LOCKDIR,
		(int) major( buf.st_dev ),
 		(int) major( buf.st_rdev ),
		(int) minor( buf.st_rdev )
	);

#endif /* FHS */

	if( stat( file, &buf ) == 0 )
	{

		/* check if its a stale lock */
		fd=open( file, O_RDONLY );
		read( fd, pid_buffer, 11 );
		/* FIXME null terminiate pid_buffer? need to check in Solaris */
		close( fd );
		sscanf( pid_buffer, "%d", &pid );

		if( kill( (pid_t) pid, 0 ) && errno==ESRCH )
		{
			sprintf( message,
				"RXTX Warning:  Removing stale lock file. %s\n",
				file );
			syslog( LOG_INFO, message );
			if( unlink( file ) != 0 )
			{
				snprintf( message, 80, "RXTX Error:  Unable to \
					remove stale lock file: %s\n",
					file
				);
				syslog( LOG_INFO, message );
				return 1;
			}
		}
	}
	return 0;
}
int init( void )
{
	pid_t pid;

	if(  ( pid = fork() ) < 0 )
	{
		return(-1);
	} 
	else if ( pid != 0 )
	{
		exit( 0 );
	}
	setsid();
	chdir("/");
	umask( 0 );
	return( 0 );
}
int process_requests( int cfd )
{
	for(;;)
	{
		char str[80];
		char str2[80];
		char *p;
		int ret;

		ret = read( cfd, str, 80 );
		
		if( ret < 80 && ret > 1 )
			str[ret] = '\0';
		else
			str[79] = '\0';
		if ( !strncasecmp( str, "quit", 4 ) )
		{
			write( cfd, "Exit\n", strlen( "Exit\n" ) );
			//sprintf( str,  M220 );
			//write( cfd, str, strlen( str ) );
			sprintf( str, "221 Thank you for using the Lock File service on %s.\n", hostname );
			write( cfd, str, strlen( str ) );
			return( 1 );
		}
		else if( !strncasecmp( str, "lock ", 4 ) )
		{
			char *q,*r;
			p = str + 5;
			q=p;
			while( *q != ' ' && *q != '\0' )
				q++;
			if ( *q == '\0' )
			{
				write( cfd, M450, strlen( M450 ) );
				return(0);
			}
			*q = '\0';
			q++;
			r=q; 
			while( *r != '\n' && *r != '\0' )
				r++;
			if( *r == '\n' )
				*r = '\0';
			if ( LOCK( p, atoi( q ) ) )
				write( cfd, M450, strlen( M450 ) );
			write( cfd, M200, strlen( M200 ) );
		}
		else if( !strncasecmp( str, "unlock ", 6 ) )
		{
			char *q,*r;
			p = str + 7;
			q=p;
			while( *q != ' ' && *q != '\0' )
				q++;
			if ( *q == '\0' )
			{
				write( cfd, "q=0\n", strlen( "q=0\n" ) );
				write( cfd, M450, strlen( M450 ) );
				return(0);
			}
			*q = '\0';
			q++;
			r=q; 
			while( *r != '\n' && *r != '\0' )
				r++;
			if( *r == '\n' )
				*r = '\0';
			if ( UNLOCK( (const char *) p, atoi( q ) ) )
			{
				write( cfd, M450, strlen( M450 ) );
			}
			write( cfd, M200, strlen( M200 ) );
		}
		else
		{
			str[ret-2]='\0';
			sprintf( str2, M500 );
			write( cfd, str2, strlen(str2));
		}
		//sprintf( str2, "%i\n", strlen(str) );
		//write( cfd, str2, strlen(str2) );
		//sprintf( str2, "%i\n", ret );
		//write( cfd, str2, strlen(str2) );
		//write( cfd, str, strlen(str) );
	}
}
int main( int argc, char **argv )
{
	char *ptr;
	char str[128];
	char portstr[7];
	int fd, cfd;
	struct sockaddr *cliaddr;
	socklen_t len, addrlen;
	struct sockaddr_in *sin;
	struct addrinfo a_info, *results, *backup;
	const int on = -1;

	/*  become a daemon */
	if( argc != 3 )
	{
		fprintf( stderr, "usage:  %s host port\n", argv[0] );
		exit(1);
	}
	init();
	gethostname( hostname, 255 );
	hostname[256]='\0';
	openlog( "rxtx", LOG_PID, LOG_UUCP );
	syslog( LOG_INFO, "Lock Daemon Initialized" );

	bzero( &a_info, sizeof( struct addrinfo ) );
	a_info.ai_flags = AI_PASSIVE;
	a_info.ai_family = AF_UNSPEC;
	a_info.ai_socktype = SOCK_STREAM;

	if( getaddrinfo( argv[1], argv[2], &a_info, &results ))
	{
		syslog( LOG_INFO, "Lock Daemon failed" );
		goto exit;
	}
	backup = results;
	do
	{
		fd = socket( results->ai_family, results->ai_socktype,
			results->ai_protocol );
		if ( fd < 0 ) continue;
		setsockopt( fd, SOL_SOCKET, SO_REUSEADDR, &on, sizeof(on) );
		if ( bind( fd, results->ai_addr, results->ai_addrlen ) == 0 ) break;
		if ( results == NULL )
		{
			printf( "results is null\n" );
			goto exit;
		}
		close( fd );
	
	} while ( ( results = results->ai_next) != NULL );
	if( fd < 0 )
	{
	}

	if ( ( ptr = getenv( "LISTENQ" ) ) != NULL )
		addrlen = atoi(ptr);
	if( listen( fd, 1024 ) < 0 )
	{
		perror( strerror(errno));
		printf( "fd is %i is another daemon running?\n", fd );
		goto exit;
	}

	if ( &len )
		len = results->ai_addrlen;
	freeaddrinfo( backup );
	cliaddr= malloc( addrlen );
		len = addrlen;
		cfd = accept( fd, cliaddr, &len );
		sin = ( struct sockaddr_in * ) cliaddr;
		if ( !inet_ntop( AF_INET, &(sin->sin_addr), str, sizeof(str) ) )
			str[0] = '\0';
		if ( !ntohs( sin->sin_port ) )
		{
			snprintf( portstr, sizeof( portstr ), ".%d", ntohs( sin->sin_port) );
			strcat( str, portstr);
		}
		fprintf( stderr, "connected from %s\n", str );
		sprintf( str,  M220 );
		write( cfd, str, strlen( str ) );
	for(;;)
	{
		if (process_requests( cfd ))
		{
			close( cfd );
			goto exit;
		}
	}
	syslog( LOG_INFO, "Lock Daemon Shutting down" );
exit:
	closelog();
	exit(0);
}