2005-06-05 06:41:09 +04:00
/*
* udevcontrol . c
*
* Copyright ( C ) 2005 Kay Sievers < kay . sievers @ vrfy . org >
*
* This program is free software ; you can redistribute it and / or modify it
* under the terms of the GNU General Public License as published by the
* Free Software Foundation version 2 of the License .
*
* This program is distributed in the hope that it will be useful , but
* WITHOUT ANY WARRANTY ; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE . See the GNU
* General Public License for more details .
*
* You should have received a copy of the GNU General Public License along
* with this program ; if not , write to the Free Software Foundation , Inc . ,
* 675 Mass Ave , Cambridge , MA 0213 9 , USA .
*
*/
# include <time.h>
# include <errno.h>
# include <stdio.h>
# include <stdlib.h>
# include <stddef.h>
# include <string.h>
# include <unistd.h>
2006-05-01 22:36:21 +04:00
# include <sys/types.h>
# include <sys/socket.h>
# include <sys/wait.h>
# include <sys/un.h>
2005-06-05 06:41:09 +04:00
# include "udev.h"
# include "udevd.h"
static int sock = - 1 ;
2005-10-27 22:32:07 +04:00
static int udev_log = 0 ;
2005-06-05 06:41:09 +04:00
# ifdef USE_LOG
2005-06-16 03:58:47 +04:00
void log_message ( int priority , const char * format , . . . )
2005-06-05 06:41:09 +04:00
{
va_list args ;
2005-10-27 22:32:07 +04:00
if ( priority > udev_log )
2005-06-16 03:58:47 +04:00
return ;
2005-06-05 06:41:09 +04:00
va_start ( args , format ) ;
2005-06-16 03:58:47 +04:00
vsyslog ( priority , format , args ) ;
2005-06-05 06:41:09 +04:00
va_end ( args ) ;
}
# endif
2006-07-03 03:03:53 +04:00
static void usage ( void )
{
printf ( " Usage: udevcontrol COMMAND \n "
2006-08-10 14:50:53 +04:00
" log_priority=<level> set the udev log level for the daemon \n "
" stop_exec_queue keep udevd from executing events, queue only \n "
" start_exec_queue execute events, flush queue \n "
" reload_rules reloads the rules files \n "
" max_childs=<N> maximum number of childs \n "
" max_childs_running=<N> maximum number of childs running at the same time \n "
" --help print this help text \n \n " ) ;
2006-07-03 03:03:53 +04:00
}
2005-06-05 06:41:09 +04:00
int main ( int argc , char * argv [ ] , char * envp [ ] )
{
2006-08-05 15:22:44 +04:00
static struct udevd_ctrl_msg ctrl_msg ;
2005-06-05 06:41:09 +04:00
struct sockaddr_un saddr ;
socklen_t addrlen ;
2005-06-16 03:58:47 +04:00
const char * env ;
2005-06-16 05:22:27 +04:00
const char * val ;
int * intval ;
2005-08-11 22:34:24 +04:00
int i ;
2005-06-05 06:41:09 +04:00
int retval = 1 ;
2005-06-16 03:58:47 +04:00
env = getenv ( " UDEV_LOG " ) ;
if ( env )
2005-10-27 22:32:07 +04:00
udev_log = log_priority ( env ) ;
2005-06-16 03:58:47 +04:00
2005-06-05 06:41:09 +04:00
logging_init ( " udevcontrol " ) ;
dbg ( " version %s " , UDEV_VERSION ) ;
2005-08-11 22:34:24 +04:00
if ( argc < 2 ) {
fprintf ( stderr , " missing command \n \n " ) ;
2006-07-03 03:03:53 +04:00
usage ( ) ;
2005-06-05 06:41:09 +04:00
goto exit ;
}
2006-08-05 15:22:44 +04:00
memset ( & ctrl_msg , 0x00 , sizeof ( struct udevd_ctrl_msg ) ) ;
strcpy ( ctrl_msg . magic , UDEVD_CTRL_MAGIC ) ;
2005-06-05 06:41:09 +04:00
2005-08-11 22:34:24 +04:00
for ( i = 1 ; i < argc ; i + + ) {
char * arg = argv [ i ] ;
if ( ! strcmp ( arg , " stop_exec_queue " ) )
2006-08-05 15:22:44 +04:00
ctrl_msg . type = UDEVD_CTRL_STOP_EXEC_QUEUE ;
2005-08-11 22:34:24 +04:00
else if ( ! strcmp ( arg , " start_exec_queue " ) )
2006-08-05 15:22:44 +04:00
ctrl_msg . type = UDEVD_CTRL_START_EXEC_QUEUE ;
2005-10-27 23:04:38 +04:00
else if ( ! strcmp ( arg , " reload_rules " ) )
2006-08-05 15:22:44 +04:00
ctrl_msg . type = UDEVD_CTRL_RELOAD_RULES ;
2005-08-11 22:34:24 +04:00
else if ( ! strncmp ( arg , " log_priority= " , strlen ( " log_priority= " ) ) ) {
2006-08-05 15:22:44 +04:00
intval = ( int * ) ctrl_msg . buf ;
2005-08-11 22:34:24 +04:00
val = & arg [ strlen ( " log_priority= " ) ] ;
2006-08-05 15:22:44 +04:00
ctrl_msg . type = UDEVD_CTRL_SET_LOG_LEVEL ;
2005-08-11 22:34:24 +04:00
* intval = log_priority ( val ) ;
info ( " send log_priority=%i " , * intval ) ;
} else if ( ! strncmp ( arg , " max_childs= " , strlen ( " max_childs= " ) ) ) {
2006-08-10 14:50:53 +04:00
char * endp ;
int count ;
2006-08-05 15:22:44 +04:00
intval = ( int * ) ctrl_msg . buf ;
2005-08-11 22:34:24 +04:00
val = & arg [ strlen ( " max_childs= " ) ] ;
2006-08-05 15:22:44 +04:00
ctrl_msg . type = UDEVD_CTRL_SET_MAX_CHILDS ;
2006-08-10 14:50:53 +04:00
count = strtoul ( val , & endp , 0 ) ;
if ( endp [ 0 ] ! = ' \0 ' | | count < 1 ) {
fprintf ( stderr , " invalid number \n " ) ;
goto exit ;
}
* intval = count ;
2005-08-11 22:34:24 +04:00
info ( " send max_childs=%i " , * intval ) ;
2006-08-10 14:50:53 +04:00
} else if ( ! strncmp ( arg , " max_childs_running= " , strlen ( " max_childs_running= " ) ) ) {
char * endp ;
int count ;
intval = ( int * ) ctrl_msg . buf ;
val = & arg [ strlen ( " max_childs_running= " ) ] ;
ctrl_msg . type = UDEVD_CTRL_SET_MAX_CHILDS_RUNNING ;
count = strtoul ( val , & endp , 0 ) ;
if ( endp [ 0 ] ! = ' \0 ' | | count < 1 ) {
fprintf ( stderr , " invalid number \n " ) ;
goto exit ;
}
* intval = count ;
info ( " send max_childs_running=%i " , * intval ) ;
2005-08-11 22:34:24 +04:00
} else if ( strcmp ( arg , " help " ) = = 0 | | strcmp ( arg , " --help " ) = = 0 | | strcmp ( arg , " -h " ) = = 0 ) {
2006-07-03 03:03:53 +04:00
usage ( ) ;
goto exit ;
2005-08-11 22:34:24 +04:00
} else {
fprintf ( stderr , " unknown option \n \n " ) ;
2006-07-03 03:03:53 +04:00
usage ( ) ;
goto exit ;
2005-08-11 22:34:24 +04:00
}
}
if ( getuid ( ) ! = 0 ) {
fprintf ( stderr , " need to be root, exit \n \n " ) ;
2006-07-03 03:03:53 +04:00
goto exit ;
2005-06-05 06:41:09 +04:00
}
sock = socket ( AF_LOCAL , SOCK_DGRAM , 0 ) ;
if ( sock = = - 1 ) {
2005-11-07 20:44:18 +03:00
err ( " error getting socket: %s " , strerror ( errno ) ) ;
2005-06-05 06:41:09 +04:00
goto exit ;
}
memset ( & saddr , 0x00 , sizeof ( struct sockaddr_un ) ) ;
saddr . sun_family = AF_LOCAL ;
/* use abstract namespace for socket path */
2006-08-05 15:22:44 +04:00
strcpy ( & saddr . sun_path [ 1 ] , UDEVD_CTRL_SOCK_PATH ) ;
2005-06-05 06:41:09 +04:00
addrlen = offsetof ( struct sockaddr_un , sun_path ) + strlen ( saddr . sun_path + 1 ) + 1 ;
2006-08-05 15:22:44 +04:00
retval = sendto ( sock , & ctrl_msg , sizeof ( ctrl_msg ) , 0 , ( struct sockaddr * ) & saddr , addrlen ) ;
2005-06-14 00:38:42 +04:00
if ( retval = = - 1 ) {
2005-11-07 20:44:18 +03:00
err ( " error sending message: %s " , strerror ( errno ) ) ;
2005-06-14 00:38:42 +04:00
retval = 1 ;
} else {
2006-08-05 15:22:44 +04:00
dbg ( " sent message type=0x%02x, %u bytes sent " , ctrl_msg . type , retval ) ;
2005-06-14 00:38:42 +04:00
retval = 0 ;
}
2005-06-05 06:41:09 +04:00
close ( sock ) ;
exit :
logging_close ( ) ;
return retval ;
}