示例#1
0
文件: stat.c 项目: KDE/kde-workspace
void printCtxt( const char* cmd ) {
	(void)cmd;
	
	if ( StatDirty )
		processStat();
	
	output( "%f\n", (float)( Ctxt / timeInterval ) );
}
示例#2
0
文件: stat.c 项目: KDE/kde-workspace
void printCPUTotalLoad( const char* cmd ) {
	(void)cmd;
	
	if ( StatDirty )
		processStat();
	
	output( "%f\n", CPULoad.userLoad + CPULoad.sysLoad + CPULoad.niceLoad + CPULoad.waitLoad );
}
示例#3
0
文件: stat.c 项目: KDE/kde-workspace
void printCPUIdle( const char* cmd ) {
	(void)cmd;
	
	if ( StatDirty )
		processStat();
	
	output( "%f\n", CPULoad.idleLoad );
}
示例#4
0
文件: stat.c 项目: KDE/kde-workspace
void printCPUSys( const char* cmd ) {
	(void)cmd;
	
	if ( StatDirty )
		processStat();
	
	output( "%f\n", CPULoad.sysLoad );
}
示例#5
0
文件: stat.c 项目: KDE/kde-workspace
void printCPUUser( const char* cmd ) {
	(void)cmd;
	
	if ( StatDirty )
		processStat();
	
	output( "%f\n", CPULoad.userLoad );
}
示例#6
0
文件: stat.c 项目: KDE/kde-workspace
void printInterruptx( const char* cmd ) {
	int id;
	
	if ( StatDirty )
		processStat();
	
	sscanf( cmd + strlen( "cpu/interrupts/int" ), "%d", &id );
	output( "%f\n", (float)( Intr[ id ] / timeInterval ) );
}
示例#7
0
文件: stat.c 项目: KDE/kde-workspace
void printCPUxIdle( const char* cmd ) {
	int id;
	
	if ( StatDirty )
		processStat();
	
	sscanf( cmd + 7, "%d", &id );
	output( "%f\n", SMPLoad[ id ].idleLoad );
}
示例#8
0
文件: stat.c 项目: KDE/kde-workspace
void printCPUxTotalLoad( const char* cmd ) {
	int id;
	
	if ( StatDirty )
		processStat();
	
	sscanf( cmd + 7, "%d", &id );
	output( "%f\n", SMPLoad[ id ].userLoad + SMPLoad[ id ].sysLoad + SMPLoad[ id ].niceLoad + SMPLoad[ id ].waitLoad );
}
示例#9
0
文件: stat.c 项目: KDE/kde-workspace
void printCPUWait( const char* cmd )
{
	(void)cmd;

	if ( StatDirty )
		processStat();

	output( "%f\n", CPULoad.waitLoad );
}
示例#10
0
文件: stat.c 项目: KDE/kde-workspace
void print24DiskWBlk( const char* cmd ) {
	int id;
	
	if ( StatDirty )
		processStat();
	
	sscanf( cmd + 9, "%d", &id );
	/* a block is 512 bytes or 1/2 kBytes */
	output( "%f\n", (float)( DiskLoad[ id ].s[ 4 ].delta / timeInterval * 2 ) );
}
示例#11
0
文件: stat.c 项目: KDE/kde-workspace
void print24DiskWIO( const char* cmd ) {
	int id;
	
	if ( StatDirty )
		processStat();
	
	sscanf( cmd + 9, "%d", &id );
	output( "%f\n", (float)( DiskLoad[ id ].s[ 2 ].delta
							/ timeInterval ) );
}
示例#12
0
文件: stat.c 项目: KDE/kde-workspace
void print24DiskIO( const char* cmd ) {
	int major, minor;
	char devname[DISKDEVNAMELEN];
	char name[ 17 ];
	DiskIOInfo* ptr;
	
	sscanf( cmd, "disk/%[^_]_(%d:%d)/%16s", devname, &major, &minor, name );
	
	if ( StatDirty )
		processStat();
	
	ptr = DiskIO;
	while ( ptr && ( ptr->major != major || ptr->minor != minor ) )
		ptr = ptr->next;
	
	if ( !ptr ) {
		print_error( "RECONFIGURE" );
		output( "0\n" );
		
		log_error( "Disk device disappeared" );
		return;
	}
	
	if ( strcmp( name, "total" ) == 0 )
		output( "%f\n", (float)( ptr->total.delta / timeInterval ) );
	else if ( strcmp( name, "rio" ) == 0 )
		output( "%f\n", (float)( ptr->rio.delta / timeInterval ) );
	else if ( strcmp( name, "wio" ) == 0 )
		output( "%f\n", (float)( ptr->wio.delta / timeInterval ) );
	else if ( strcmp( name, "rblk" ) == 0 )
		output( "%f\n", (float)( ptr->rblk.delta / ( timeInterval * 2 ) ) );
	else if ( strcmp( name, "wblk" ) == 0 )
		output( "%f\n", (float)( ptr->wblk.delta / ( timeInterval * 2 ) ) );
	else {
		output( "0\n" );
		log_error( "Unknown disk device property \'%s\'", name );
	}
}
示例#13
0
文件: stat.c 项目: KDE/kde-workspace
void initStat( struct SensorModul* sm ) {
	/* The CPU load is calculated from the values in /proc/stat. The cpu
	* entry contains 7 counters. These counters count the number of ticks
	* the system has spend on user processes, system processes, nice
	* processes, idle and IO-wait time, hard and soft interrupts.
	*
	* SMP systems will have cpu1 to cpuN lines right after the cpu info. The
	* format is identical to cpu and reports the information for each cpu.
	* Linux kernels <= 2.0 do not provide this information!
	*
	* The /proc/stat file looks like this:
	*
	* cpu  <user> <nice> <system> <idling> <waiting> <hardinterrupt> <softinterrupt>
	* disk 7797 0 0 0
	* disk_rio 6889 0 0 0
	* disk_wio 908 0 0 0
	* disk_rblk 13775 0 0 0
	* disk_wblk 1816 0 0 0
	* page 27575 1330
	* swap 1 0
	* intr 50444 38672 2557 0 0 0 0 2 0 2 0 0 3 1429 1 7778 0
	* ctxt 54155
	* btime 917379184
	* processes 347 
	*
	* Linux kernel >= 2.4.0 have one or more disk_io: lines instead of
	* the disk_* lines.
	*
	* Linux kernel >= 2.6.x(?) have disk I/O stats in /proc/diskstats
	* and no disk relevant lines are found in /proc/stat
	*/
	
	char format[ 32 ];
	char tagFormat[ 16 ];
	char buf[ 1024 ];
	char tag[ 32 ];
	
	StatSM = sm;
	
	sprintf( format, "%%%d[^\n]\n", (int)sizeof( buf ) - 1 );
	sprintf( tagFormat, "%%%ds", (int)sizeof( tag ) - 1 );

    FILE *stat = fopen("/proc/stat", "r");
    if(!stat) {
		print_error( "Cannot open file \'/proc/stat\'!\n"
				"The kernel needs to be compiled with support\n"
				"for /proc file system enabled!\n" );
		return;
    }
	while ( fscanf( stat, format, buf ) == 1 ) {
		buf[ sizeof( buf ) - 1 ] = '\0';
		sscanf( buf, tagFormat, tag );
		
		if ( strcmp( "cpu", tag ) == 0 ) {
			/* Total CPU load */
			registerMonitor( "cpu/system/user", "float", printCPUUser, printCPUUserInfo, StatSM );
			registerMonitor( "cpu/system/nice", "float", printCPUNice, printCPUNiceInfo, StatSM );
			registerMonitor( "cpu/system/sys", "float", printCPUSys, printCPUSysInfo, StatSM );
			registerMonitor( "cpu/system/TotalLoad", "float", printCPUTotalLoad, printCPUTotalLoadInfo, StatSM );
			registerMonitor( "cpu/system/idle", "float", printCPUIdle, printCPUIdleInfo, StatSM );
			registerMonitor( "cpu/system/wait", "float", printCPUWait, printCPUWaitInfo, StatSM );

			/* Monitor names changed from kde3 => kde4. Remain compatible with legacy requests when possible. */
			registerLegacyMonitor( "cpu/user", "float", printCPUUser, printCPUUserInfo, StatSM );
			registerLegacyMonitor( "cpu/nice", "float", printCPUNice, printCPUNiceInfo, StatSM );
			registerLegacyMonitor( "cpu/sys", "float", printCPUSys, printCPUSysInfo, StatSM );
			registerLegacyMonitor( "cpu/TotalLoad", "float", printCPUTotalLoad, printCPUTotalLoadInfo, StatSM );
			registerLegacyMonitor( "cpu/idle", "float", printCPUIdle, printCPUIdleInfo, StatSM );
			registerLegacyMonitor( "cpu/wait", "float", printCPUWait, printCPUWaitInfo, StatSM );
		}
		else if ( strncmp( "cpu", tag, 3 ) == 0 ) {
			char cmdName[ 24 ];
			/* Load for each SMP CPU */
			int id;
			
			sscanf( tag + 3, "%d", &id );
			CPUCount++;
			sprintf( cmdName, "cpu/cpu%d/user", id );
			registerMonitor( cmdName, "float", printCPUxUser, printCPUxUserInfo, StatSM );
			sprintf( cmdName, "cpu/cpu%d/nice", id );
			registerMonitor( cmdName, "float", printCPUxNice, printCPUxNiceInfo, StatSM );
			sprintf( cmdName, "cpu/cpu%d/sys", id );
			registerMonitor( cmdName, "float", printCPUxSys, printCPUxSysInfo, StatSM );
			sprintf( cmdName, "cpu/cpu%d/TotalLoad", id );
			registerMonitor( cmdName, "float", printCPUxTotalLoad, printCPUxTotalLoadInfo, StatSM );
			sprintf( cmdName, "cpu/cpu%d/idle", id );
			registerMonitor( cmdName, "float", printCPUxIdle, printCPUxIdleInfo, StatSM );
			sprintf( cmdName, "cpu/cpu%d/wait", id );
			registerMonitor( cmdName, "float", printCPUxWait, printCPUxWaitInfo, StatSM );
		}
		else if ( strcmp( "disk", tag ) == 0 ) {
			unsigned long val;
			char* b = buf + 5;
			
			/* Count the number of registered disks */
			for ( DiskCount = 0; *b && sscanf( b, "%lu", &val ) == 1; DiskCount++ ) {
				while ( *b && isblank( *b++ ) );
				while ( *b && isdigit( *b++ ) );
			}
			
			if ( DiskCount > 0 )
				DiskLoad = (DiskLoadInfo*)malloc( sizeof( DiskLoadInfo ) * DiskCount );

			initStatDisk( tag, buf, "disk", "disk", 0, print24DiskTotal, print24DiskTotalInfo );
		}
		else if ( initStatDisk( tag, buf, "disk_rio", "rio", 1, print24DiskRIO, print24DiskRIOInfo ) );
		else if ( initStatDisk( tag, buf, "disk_wio", "wio", 2, print24DiskWIO, print24DiskWIOInfo ) );
		else if ( initStatDisk( tag, buf, "disk_rblk", "rblk", 3, print24DiskRBlk, print24DiskRBlkInfo ) );
		else if ( initStatDisk( tag, buf, "disk_wblk", "wblk", 4, print24DiskWBlk, print24DiskWBlkInfo ) );
		else if ( strcmp( "disk_io:", tag ) == 0 )
			process24DiskIO( buf );
		else if ( strcmp( "page", tag ) == 0 ) {
			sscanf( buf + 5, "%lu %lu", &OldPageIn, &OldPageOut );
			registerMonitor( "cpu/pageIn", "float", printPageIn, printPageInInfo, StatSM );
			registerMonitor( "cpu/pageOut", "float", printPageOut, printPageOutInfo, StatSM );
		}
		else if ( strcmp( "intr", tag ) == 0 ) {
			unsigned int i;
			char cmdName[ 32 ];
			char* p = buf + 5;
			
			/* Count the number of listed values in the intr line. */
			NumOfInts = 0;
			while ( *p )
				if ( *p++ == ' ' )
					NumOfInts++;
			
			/* It looks like anything above 24 is always 0. So let's just
			* ignore this for the time being. */
			if ( NumOfInts > 25 )
				NumOfInts = 25;
			OldIntr = (unsigned long*)malloc( NumOfInts * sizeof( unsigned long ) );
			Intr = (unsigned long*)malloc( NumOfInts * sizeof( unsigned long ) );
			i = 0;
			p = buf + 5;
			for ( i = 0; p && i < NumOfInts; i++ ) {
				sscanf( p, "%lu", &OldIntr[ i ] );
				while ( *p && *p != ' ' )
					p++;
				while ( *p && *p == ' ' )
					p++;
				sprintf( cmdName, "cpu/interrupts/int%02d", i );
				registerMonitor( cmdName, "float", printInterruptx, printInterruptxInfo, StatSM );
			}
		}
		else if ( strcmp( "ctxt", tag ) == 0 ) {
			sscanf( buf + 5, "%lu", &OldCtxt );
			registerMonitor( "cpu/context", "float", printCtxt, printCtxtInfo, StatSM );
		}
	}
    fclose(stat);

	stat = fopen("/proc/vmstat", "r");
    if(!stat) {
		print_error( "Cannot open file \'/proc/vmstat\'\n");
    } else {
        while ( fscanf( stat, format, buf ) == 1 ) {
            buf[ sizeof( buf ) - 1 ] = '\0';
            sscanf( buf, tagFormat, tag );

            if ( strcmp( "pgpgin", tag ) == 0 ) {
                sscanf( buf + 7, "%lu", &OldPageIn );
                registerMonitor( "cpu/pageIn", "float", printPageIn, printPageInInfo, StatSM );
            }
            else if ( strcmp( "pgpgout", tag ) == 0 ) {
                sscanf( buf + 7, "%lu", &OldPageOut );
                registerMonitor( "cpu/pageOut", "float", printPageOut, printPageOutInfo, StatSM );
            }
        }
        fclose(stat);
    }
	if ( CPUCount > 0 )
		SMPLoad = (CPULoadInfo*)calloc( CPUCount, sizeof( CPULoadInfo ) );
	
	/* Call processStat to eliminate initial peek values. */
	processStat();
}
示例#14
0
/**
 * Processes all the POP3 commands such as
 * USER, PASS, LIST, RETR, DELE, NOOP, RSET, STAT
 */
int processPOPCommands(int sockfd, char *msg) {
	char *clientMsg = NULL;
	clientMsg = (char *)malloc(sizeof(char *) * 1024);
	if (clientMsg == NULL) {
		perror("ERROR: Cannot allocate memory");
		return(-1);
	}
	if (strncasecmp(msg, POP_SSL_STARTTLS, strlen(POP_SSL_STARTTLS)) == 0) { //EHLO
		if (setupSSLCommunication(sockfd)) {
			writeClient(sockfd, "OK Begin TLS negotiation now", TRUE);
		}
	}
	else if (strncasecmp(msg, POP_USER, strlen(POP_USER)) == 0) { //USER
		if (checkPOPStates(iPOP_USER)) {
			if (processUser(msg)== -1) {
				strcpy(clientMsg,"User name required");
				writeClient(sockfd, getMessage(TRUE, &clientMsg), TRUE);
			}
			else
				writeClient(sockfd, POP_OK, TRUE);
		}
		else {
			strcpy(clientMsg,"Invalid State");
			writeClient(sockfd, getMessage(TRUE, &clientMsg), TRUE);
		}
	}
	else if (strncasecmp(msg, POP_PASS, strlen(POP_PASS)) == 0) { //PASS
		if (checkPOPStates(iPOP_PASS)) {
			if (processPassword(msg) == -1) {
				strcpy(clientMsg,"Password required");
				writeClient(sockfd, getMessage(TRUE, &clientMsg), TRUE);
			}
			else {
				struct userdata *user;
				if (fetch_user_data(username, password, &user)) { //VALID USER

					//GET MESSAGE LISTING FOR THE USER
					getListMessages(username);

					writeClient(sockfd, POP_OK, TRUE);
					free(user);
				}
				else {
					strcpy(clientMsg,"Invalid User");
					writeClient(sockfd, getMessage(TRUE, &clientMsg), TRUE);
				}
			}
		}
		else {
			strcpy(clientMsg,"Invalid State");
			writeClient(sockfd, getMessage(TRUE, &clientMsg), TRUE);
		}
	}
	else if (strncasecmp(msg, POP_LIST, strlen(POP_LIST)) == 0) { //LIST
		if (checkPOPStates(iPOP_LIST))
			processList(sockfd, msg);
		else {
			strcpy(clientMsg,"Invalid State");
			writeClient(sockfd, getMessage(TRUE, &clientMsg), TRUE);
		}
	}
	else if (strncasecmp(msg, POP_RETR, strlen(POP_RETR)) == 0) { //RETR
		if (checkPOPStates(iPOP_RETR)) {
			if (processRetr(sockfd, msg) == -1) {
				strcpy(clientMsg,"Invalid Syntax");
				writeClient(sockfd, getMessage(TRUE, &clientMsg), TRUE);
			}
		}
		else {
			strcpy(clientMsg,"Invalid State");
			writeClient(sockfd, getMessage(TRUE, &clientMsg), TRUE);
		}
	}
	else if (strncasecmp(msg, POP_DELE, strlen(POP_DELE)) == 0) { //DELE
		if (checkPOPStates(iPOP_DELE)) {
			if (processDelete(sockfd, msg)== -1) {
				strcpy(clientMsg,"Invalid Syntax");
				writeClient(sockfd, getMessage(TRUE, &clientMsg), TRUE);
			}
		}
		else {
			strcpy(clientMsg,"Invalid State");
			writeClient(sockfd, getMessage(TRUE, &clientMsg), TRUE);
		}
	}
	else if (strncasecmp(msg, POP_RSET, strlen(POP_RSET)) == 0) { //RSET
//		if (checkStates(iPOP_RSET))
//			processRset(sockfd, msg);
//		else
//			writeClient(sockfd, POP_RESP_503, TRUE);
	}
	else if (strncasecmp(msg, POP_NOOP, strlen(POP_NOOP)) == 0) { //NOOP
		if (checkPOPStates(iPOP_NOOP))
			writeClient(sockfd, POP_OK, TRUE);
		else
			writeClient(sockfd, POP_ERR, TRUE);
	}
	else if (strncasecmp(msg, POP_STAT, strlen(POP_STAT)) == 0) { //STAT
		if (checkPOPStates(iPOP_STAT)) {
			processStat(sockfd, msg);
		}
		else {
			strcpy(clientMsg,"Invalid State");
			writeClient(sockfd, getMessage(TRUE, &clientMsg), TRUE);
		}
	}
	else {
		strcpy(clientMsg,"Invalid State");
		writeClient(sockfd,getMessage(TRUE, &clientMsg), TRUE);
	}
	free(clientMsg);
	return(0);
}