tools

service_info.cpp (10485B)

---

 // Copyright (c) 2020 Morel Bérenger
 // 
 // This software is provided 'as-is', without any express or implied
 // warranty. In no event will the authors be held liable for any damages
 // arising from the use of this software.
 // 
 // Permission is granted to anyone to use this software for any purpose,
 // including commercial applications, and to alter it and redistribute it
 // freely, subject to the following restrictions:
 // 
 // 1. The origin of this software must not be misrepresented; you must not
 //    claim that you wrote the original software. If you use this software
 //    in a product, an acknowledgment in the product documentation would be
 //    appreciated but is not required.
 // 2. Altered source versions must be plainly marked as such, and must not be
 //    misrepresented as being the original software.
 // 3. This notice may not be removed or altered from any source distribution.
 
 #include <string.h>
 #include <assert.h>
 #include <string.h>
 #include <errno.h>
 #include <limits.h>
 #include <fnmatch.h>
 
 #include <sys/types.h>
 #include <sys/stat.h>
 #include <fcntl.h>
 #include <unistd.h>
 #include <poll.h>
 
 #include <iterator>
 
 #include <utils.hpp>
 #include <vector.hpp>
 #include <memory.hpp>
 
 #include "service_info.hpp"
 
 // linux only
 #include <sys/inotify.h>
 
 //bool svi_read( pollfd& pfd, poll_ev& pev );
 void svi_release( service_info_t* svi );
 //void svi_error( pollfd& pfd, poll_ev& pev );
 
 // return true on error.
 // parses a CLI arg, stores result into a service_info
 // instance, which is then added to "var", a vector of
 // service_info.
 bool add_serv_info( void* var, char* arg )
 {
 	if( !var )
 	{
 		return true;
 	}
 
 	// initialize the service_info_t object (dynamic)
 	auto services = reinterpret_cast<vector<service_info_t>*>( var );
 	service_info_t svi;
 	uint16_t next = 0;
 	size_t arglen = strlen( arg );
 	char * end = arg + arglen;
 	if( arglen > UINT16_MAX )
 	{
 		return true;
 	}
 
 	//change the ':' separators into \0 since we use C(++). This
 	//avoids copying data into other memory areas and use of pointers.
 	svi.path = arg;
 	if( arg[next] )
 	{
 		svi.filename = next += find_unescaped( ':', '\\', arg + next, end );
 		arg[next] = 0; ++next;
 	}
 	if( arg[next] )
 	{
 		svi.svstart = next += find_unescaped( ':', '\\', arg + next, end );
 		arg[next] = 0; ++next;
 	}
 	if( arg[next] )
 	{
 		svi.svstop  = next += find_unescaped( ':', '\\', arg + next, end );
 		arg[next] = 0; ++next;
 	}
 	if( arg[next] )
 	{
 		next += find_unescaped( ':', '\\', arg + next, end );
 		arg[next] = 0; ++next;
 	}
 
 	//TODO verify this works as intended
 	if( svi.filename >= arglen || svi.svstart >= arglen || svi.svstop >= arglen )
 	{
 		fputs( HEADER_LOG ": missing value", stderr );
 		return true;
 	}
 
 	errno = 0;
 	unsigned long tmp = strtoul( arg + next, &end, 10 );
 	if( errno || *end )
 	{
 		syserr( "failed to read delay time" );
 		return true;
 	}
 	if( tmp > UINT16_MAX )
 	{
 		fputs( HEADER_LOG ": delay value is out of bounds (max: 65535)", stderr );
 		return true;
 	}
 	svi.live_delay = static_cast<uint16_t>( tmp );
 
 	// cmdline arg checked, add watch and open target if it exists
 	// parent dir watch
 	svi.dir_wfd = inotify_add_watch( g_inotify_watch_fd, svi.path, 0
 			| IN_CREATE // should close target and open new
 			| IN_DELETE // should close target
 			| IN_MOVE // should close target
 			//| IN_MODIFY // modify any file
 			| IN_MOVE_SELF
 			| IN_DELETE_SELF
 			| IN_EXCL_UNLINK // don't care about unlinked files
 			);
 	if( -1 == svi.dir_wfd )
 	{
 		fprintf( stderr, HEADER_LOG ": failed to watch dir: \"%s\" %s\n",
 				svi.path, strerror( errno ) );
 		return true;
 	}
 
 	fprintf( stderr, "watcher added on %s\n", svi.path );
 
 	//move back the '\0' to a '/' to have a proper, complete filename... :/
 	svi.path[svi.filename] = '/';
 	pollfd tmppfd; //unused
 	if( file_watch( svi, tmppfd ) )
 	{
 		return true;
 	}
 
 	services->push_back( std::move( svi ) );
 	return false;
 }
 
 bool file_watch( service_info_t& svi, pollfd& pfd )
 {
 	svi.file_fd = open( svi.path, O_RDONLY | O_NOCTTY );
 	if( -1 != svi.file_fd )
 	{
 		fprintf( stderr, "opened %s in read-only mode\n", svi.path );
 		svi.file_wfd = inotify_add_watch( g_inotify_watch_fd, svi.path, 0
 				| IN_MODIFY
 				//| IN_MOVE_SELF // would be dup of dir_wfd, I guess
 				//| IN_DELETE_SELF // would be dup of dir_wfd, I guess
 				| IN_EXCL_UNLINK // don't care about unlinked files
 				);
 		if( -1 == svi.file_wfd )
 		{
 			fprintf( stderr, HEADER_LOG ": failed to watch file: \"%s\" %s\n",
 					svi.path, strerror( errno ) );
 			return true; // if could open, why would it fail to register inotify?
 		}
 		fprintf( stderr, "watching %s\n", svi.path );
 	}
 	else
 	{
 		switch( errno )
 		{
 			case EINTR: //TODO sig received
 				fprintf( stderr, HEADER_LOG " signal caught\n" );
 				break;
 			case ENOENT: //files does not exists yet
 				fprintf( stderr, HEADER_LOG " file %s does not exist yet\n", svi.path );
 				break;
 
 			case EACCES: //no rights to open
 			case EFAULT: //pathname out of accessible @space
 			case ELOOP: //too many symlinks followed
 			case EMFILE: //per-process limit reached
 			case ENAMETOOLONG: //pathname too long
 			case ENFILE: //system limit reached
 			case ENOMEM: //out of kernel memory
 			case ENOTDIR: //a component should be a dir but is not
 			case EFBIG: //file too big for opening
 			case EOVERFLOW: //file too big for opening
 			case EPERM: //either O_NOATIME without rights or file sealed?
 				fprintf( stderr, HEADER_LOG " unable to open file %s: %s(%d)", svi.path, strerror( errno ), errno );
 				return true;
 
 			case EINVAL: //debug
 			case EDQUOT: //?
 			case ENODEV: //?
 
 			case EWOULDBLOCK: //can't happen
 			case EOPNOTSUPP: //can't happen
 			case ENOSPC: //can't happen
 			case EEXIST: //can't happen
 			case EISDIR: //can't happen
 			case ENXIO: //can't happen
 			case EROFS: //can't happen
 			case ETXTBSY: //can't happen
 			case EBADF: //can't happen
 			default: //can't happen
 				fprintf( stderr, HEADER_LOG " BUG: %s (%x)\n", strerror( errno ), errno );
 				abort();
 		}
 	}
 	return false;
 }
 
 bool show_serv_info( void const* val, FILE* target )
 {
 	if( !val )
 	{
 		return true;
 	}
 	auto svis = reinterpret_cast<const vector<service_info_t>*>( val );
 
 	fprintf( target, "(current: " );
 	for( auto svi : *svis )
 	{
 		fprintf( target, "path=\"%s\" start=\"%s\" stop=\"%s\" delay=%d; "
 				, svi.path
 				, svi.path + svi.svstart
 				, svi.path + svi.svstop
 				, svi.live_delay
 				);
 	}
 	fprintf( target, ")" );
 	return false;
 }
 
 //void svi_release( service_info_t* svi )
 //{
 //	assert( g_inotify_watch_fd >= 0 );
 //	inotify_rm_watch( svi->dir_wfd, g_inotify_watch_fd );
 //}
 
 //void svi_error( pollfd& pfd, poll_ev& pev )
 //{
 //	svi_release( pfd, pev );
 //}
 //
 //bool svi_read( pollfd& pfd, poll_ev& pev )
 //{
 //	char buf[1024];
 //	ssize_t rd = read( pfd.fd, buf, sizeof( buf ) );
 //	if( -1 == rd )
 //	{
 //		fputs( HEADER_LOG ": failed to read: ", stderr );
 //		fputs( strerror( errno ), stderr );
 //		return true;
 //	}
 //
 //	inotify_event ev;
 //	// TODO:
 //	// poll sur fd réel (pas de inotify)
 //	// surveiller actions de déplacement/suppression du fichier
 //	// ouvrir le fichier en amount si existant
 //	// ouvrir le fichier lors d'un IN_CREATE
 //	// filtrer: un seul fichier doit être vraiment surveillé
 //	for( char* ptr = buf; ptr < buf + rd;
 //			ptr += sizeof( inotify_event* ) + ev.len )
 //	{
 //		memcpy( &ev, ptr, sizeof( inotify_event ) );
 //
 //		if( ev.mask &(IN_DELETE | IN_MOVE ) )
 //		{
 //		}
 //		if( ev.mask & IN_MODIFY )
 //		{
 //		}
 //		if( ev.mask &(IN_MOVE_SELF | IN_DELETE_SELF ) )
 //		{
 //		}
 //	}
 //}
 
 size_t name_sz( service_info_t const& svc )
 {
 	//TODO: implement a real identifier
 	return svc.filename;
 }
 
 //TODO: time implementation sucks
 bool refresh( service_info_t & svc, time_t time )
 {
 	status_t s = status( svc );
 
 	char const* color = nullptr;
 	switch( s )
 	{
 		case DOWN:
 			color = g_color_down;
 			break;
 		case WAKING:
 			color = g_color_wake;
 			assert( time < UINT16_MAX );
 			svc.birth_time += time;
 			if( svc.birth_time < svc.live_delay )
 			{
 				break;
 			}
 		case UP: // fallthrough
 			color = g_color_up;
 			break;
 	}
 	assert( color );
 
 	assert( name_sz( svc ) < INT_MAX );
 	fprintf( stdout, "\x1B[%d;%dH" "\x1B[30;%sm" "%.*s" "\x1B[m\n" ,
 			svc.draw_area.y, svc.draw_area.x,
 			color,
 			static_cast<int>( name_sz( svc ) ), name( svc ) );
 	return false;
 }
 
 bool update( service_info_t & svc )
 {
 	char buf[4096];
 	size_t to_read = sizeof( buf ) - 1;
 	char *start = buf;
 
 	status_t s = status( svc );
 	ssize_t rd;
 	while( ( rd = read( svc.file_fd, start, to_read ) ) > 0 )
 	{
 		start[rd] = '\0';
 		char * end_line = start + rd - 1;
 		while( end_line >= start && *end_line != '\n' )
 		{
 			--end_line;
 		}
 		if( end_line < start )
 		{
 			fputs( "buffer too small", stderr ); //TODO mark as DOWN?
 			return true;
 		}
 		const char * const next_start = end_line + 1;
 		char const* start_line = end_line;
 		bool found = false;
 		uint16_t pattern = 0;
 
 		do
 		{
 			do
 			{
 				--start_line;
 			} while( *start_line != '\n' && start_line >= buf );
 
 			++start_line;
 			*end_line = '\0'; //POSIX standard only works nul-term, not sizes.
 
 			pattern = svc.svstart;
 			found = FNM_NOMATCH != fnmatch( svc.path + 1 + pattern , start_line, 0 );
 			if( !found )
 			{
 				pattern = svc.svstop;
 				found = FNM_NOMATCH != fnmatch( svc.path + 1 + pattern , start_line, 0 );
 			}
 
 			*end_line = '\n'; //revert changes had to do because of POSIX shit
 			--start_line;
 		} while( !found && start_line >= buf );
 
 		if( found )
 		{
 			assert( pattern != 0 );
 			if( pattern == svc.svstart )
 			{
 				s = WAKING;
 				svc.birth_time = 0;
 			}
 			else
 			{
 				s = DOWN;
 				svc.birth_time = UINT16_MAX;
 			}
 		}
 
 		if( static_cast<size_t>( rd ) == to_read )
 		{
 			assert( buf + sizeof( buf ) > next_start );
 			size_t offset = static_cast<size_t>( buf + sizeof( buf ) - next_start );
 			memmove( buf, next_start, offset );
 			start = buf + offset;
 			to_read = sizeof( buf ) - offset - 1;
 		}
 	}
 	//TODO: handle errors more correctly
 	//  EINTR: signal received
 	//  EAGAIN: file is non-blocking (should not happen but...)
 	if( -1 == rd )
 	{
 		syserr( "reading target file failed" );
 		fprintf( stderr, "%d\n", svc.file_fd );
 		return true;
 	}
 	return false;
 }
 
 status_t status( service_info_t const& svc )
 {
 	if( svc.birth_time == UINT16_MAX )
 	{
 		return DOWN;
 	}
 	if( svc.birth_time < svc.live_delay )
 	{
 		return WAKING;
 	}
 	return UP;
 }
 
 char const* name( service_info_t const& svc )
 {
 	return svc.path;
 }
 
 int g_inotify_watch_fd;