// MBREditor.cpp : Defines the entry point for the console application.
//

#include "stdafx.h"
#include "MBREditor.h"

int main(int argc, char* argv[])
{
	// Parsing arguments
	INT arg_i = 1;			// Argument index
	DWORD dataElements = 0;	// What data do we want to output / change
	DWORD action = 0;		// 0 - output to screen, 1 - read from device to file, 2 - write from file to device
	DWORD iRes;				// Function ReadMBR / WriteMBR result
	BOOL binaryOutput = 0;	// Is binary (raw) output requested flag (hexadecimal output)

	DWORD binOuptuLength = SIZE_MBR;				// Used for binary output, user can change it with a -b flag
	LPCH fileName;									// User enters this for MBR store / load
	LPCH userPath = "PhysicalDrive0";				// The device whose MBR we want to read
	CHAR devicePath[MAX_PATH_LENGTH] = "\\\\.\\";	// Default string for device naming

	LPCH buffer = NULL;								// Pointer to the local MBR buffer (after it's read from the device)
	DWORD dwBytesRead;								// ReadMBR function fills these
	DWORD dwBufferSize;
	HANDLE hVolume;									// Holds a handle to the device whose MBR we are inspecting

	// Intro output
	fprintf(stderr, "%s", intro);

	//
	// Flags are getting parsed
	//
	while (arg_i < argc)
	{
		if (argv[arg_i][0] == '-')
		{
			switch (argv[arg_i][1])
			{
				// Checking for action:
				case 'r':
					// Mandatory argument
					if ((arg_i + 1 >= argc) || (argv[arg_i + 1][0] == '-'))
					{
						fprintf(stderr, "ERROR: -r flag needs an argument representing the file name and path.\n");
						return -1;
					}
					action = 1;
					arg_i++;
					fileName = argv[arg_i];
					break;
				case 'w':
					// Mandatory argument
					if ((arg_i + 1 >= argc) || (argv[arg_i + 1][0] == '-'))
					{
						fprintf(stderr, "ERROR: -w flag needs an argument representing the file name and path.\n");
						return -1;
					}
					action = 2;
					arg_i++;
					fileName = argv[arg_i];
					break;
				// Checking for data flags (default is all of them):
				case 'c':
					dataElements = dataElements | deCode;
					break;
				case 'd':
					dataElements = dataElements | deDiskSignature;
					break;
				case 'n':
					dataElements = dataElements | deNulls;
					break;
				case 'p':
					dataElements = dataElements | dePrimaryPartitions;
					break;
				case 'm':
					dataElements = dataElements | deMBRSignature;
					break;
				// Aditional: Checking for different device location
				case 'v':
					// Mandatory argument
					if ((arg_i + 1 >= argc) || (argv[arg_i + 1][0] == '-'))
					{
						fprintf(stderr, "ERROR: -v flag needs an argument representing the volume or file to perform on.\n");
						return -1;
					}
					arg_i++;
					userPath = argv[arg_i];
					break;
				// Aditional: request for binary (hexadecimal user-readable) output only
				case 'b':
					binaryOutput = 1;
					// Optional argument
					if ((arg_i + 1 < argc) && (argv[arg_i + 1][0] != '-'))
					{
						arg_i++;
						binOuptuLength = atoi(argv[arg_i]);
						if (binOuptuLength == 0)
						{
							fprintf(stderr, "ERROR: Wrong binary output size entered.\n");
							return -1;
						}
					}
					break;
				// Help requested
				case 'h':
					fprintf(stderr, "%s", helpText);
					return 0;
				default:
					fprintf(stderr, "WARNING: Flag %s has not been defined.\n", argv[arg_i]);
			}
		}
		else
		{
			fprintf(stderr, "WARNING: Unusable argument %s.\n", argv[arg_i]);
		}
		arg_i++;
	}
	printf("\n");

	// Defaults to all data
	if (dataElements == 0) dataElements = ALL_DATA;

	// Concatenates the initial device definition "\\.\" with the user-submitted 
	// or default device.
	strncat_s(devicePath, MAX_PATH_LENGTH - 1, userPath, MAX_PATH_LENGTH - 5);

	//
	// Opening the volume for raw reading and writing
	//
	hVolume = CreateFileA(
		devicePath,
		GENERIC_READ | GENERIC_WRITE,
		FILE_SHARE_READ | FILE_SHARE_WRITE,
		NULL,
		OPEN_EXISTING,
		FILE_FLAG_NO_BUFFERING,
		NULL
	);

	if (hVolume == INVALID_HANDLE_VALUE)
	{
		// ERROR:
		fprintf(stderr, "ERROR: CreateFile function failed, error no %d\n", GetLastError());
		return -1;
	}

	//
	// Initialization finished
	//

	// Reading the MBR contents
	buffer = ReadMBR(buffer, devicePath, hVolume, &dwBytesRead, &dwBufferSize);

	if (buffer == NULL)
	{
		CloseHandle(hVolume);
		fprintf(stderr, "Unrecoverable ERROR happened in ReadMBR function. Exiting.\n");
		return -1;
	}

	switch (action)
	{
		// Output to the screen (default):
		case 0:
			if (binaryOutput)
				RawOutputData(buffer, binOuptuLength);
			else
				OutputData(buffer, dataElements);
			break;
		// Writing from MBR to binary file (total binary format, ready for ndisasm utility)
		case 1:
			iRes = PrintToFile(buffer, dataElements, fileName);
			
			// Releasing the resources
			VirtualFree(buffer, dwBufferSize, MEM_RELEASE);
			CloseHandle(hVolume);

			// Printing to file and exiting
			return iRes;
			break;
		// Writing from binary file to MBR
		case 2:
			iRes = WriteMBR(buffer, hVolume, dwBufferSize, dataElements, fileName);
			 
			// Releasing the resources
			VirtualFree(buffer, dwBufferSize, MEM_RELEASE);
			CloseHandle(hVolume);

			// Writing to MBR and exiting
			return iRes;
			break;
	}

	// Releasing the resources
	VirtualFree(buffer, dwBufferSize, MEM_RELEASE);
	CloseHandle(hVolume);

	// Finishing
	return 0;
}

//
//	LPCH ReadMBR(LPCH buffer, LPCH deviceName, HANDLE hVolume, PDWORD dwBytesRead, PDWORD dwBufferSize)
//
//	Reads master boot record data into a buffer. As we are dealing with
//	the disk device, no bufferning must be used. This means we have to
//	follow some alignment rules when reserving the memory, reading and
//	writing. These rules are explained here:
//
//	http://msdn.microsoft.com/en-us/library/cc644950%28VS.85%29.aspx
//
//	Parameters:
//		LPCH buffer				- Initial empty pointer
//		LPCH deviceName			- Pointer to the device name
//		HANDLE hVolume			- handle to the volume whose MBR is being read
//		PDWORD dwBytesRead		- Returns number of bytes read
//		PDWORD dwBufferSize		- Returns the size of the allocated page
//
//	Return value:				- Pointer to the page holding the data
LPCH ReadMBR(LPCH buffer, LPCH deviceName, HANDLE hVolume, PDWORD dwBytesRead, PDWORD dwBufferSize)
{
	DWORD iRes;						// Test result integer
	DWORD dwBytesPerSector;
	DWORD dwBufferSizeLocal;
	DWORD dwBytesReadLocal = 0;

	*dwBytesRead = 0;

	//
	// Rule no 1: File access sizes must be a number of bytes that is an
	//            integer multiple of the volume sector size.
	//
	
	iRes = GetDiskFreeSpaceA(
		deviceName,
		NULL,
		&dwBytesPerSector,
		NULL,
		NULL
	);

	if (iRes == 0)
	{
		// ERROR:
		//fprintf(stderr, "ERROR: GetDiskFreeSpace function failed, error no %d\n", GetLastError());
		
		//return NULL;
		dwBytesPerSector = 512;
	}
	

	if (dwBytesPerSector <= SIZE_MBR)
	{
		// If the sector is smaller than usual MBR size, we simply read the
		// whole MBR
		dwBufferSizeLocal = SIZE_MBR;
	}
	else
	{
		// Otherwise, we need to read more data than needed.
		dwBufferSizeLocal = dwBytesPerSector;
	}
	
	//
	// Rule no 2: File access buffer addresses for read and write operations 
	//            should be sector-aligned, which means aligned on addresses 
	//            in memory that are integer multiples of the volume sector size.
	//
	buffer = (LPCH)VirtualAlloc(NULL, dwBufferSizeLocal, MEM_COMMIT, PAGE_READWRITE);
	
	if (buffer == NULL)
	{
		// ERROR:
		fprintf(stderr, "ERROR: VirtualAlloc function failed, error no %d\n", GetLastError());

		return NULL;
	}

	//
	// Reading the MBR
	//
	// First we need to align the file pointer to 0 - the reading starting position
	iRes = SetFilePointer(hVolume, 0, NULL, FILE_BEGIN);

	if (iRes == INVALID_SET_FILE_POINTER)
	{
		// ERROR:
		fprintf(stderr, "ERROR: SetFilePointer function failed, error no %d\n", GetLastError());

		// Releasing the resources
		VirtualFree(buffer, dwBufferSizeLocal, MEM_RELEASE);

		return NULL;
	}

	// Then we issue the read command
	iRes = ReadFile(hVolume, buffer, dwBufferSizeLocal, &dwBytesReadLocal, NULL);

	if (iRes == 0)
	{
		// ERROR:
		fprintf(stderr, "ERROR: ReadFile function failed, error no %d\n", GetLastError());

		// Releasing the resources
		VirtualFree(buffer, dwBufferSizeLocal, MEM_RELEASE);

		return NULL;
	}

	// Successful return
	*dwBytesRead = dwBytesReadLocal;
	*dwBufferSize = dwBufferSizeLocal;
	return buffer;
}

//
//	void RawOutputData(LPCH buffer, DWORD size)
//
//	Outputs each character in the hexadecimal form, usually 16 chars in a
//	row. Treats each character as an ASCII char (as a byte).
VOID RawOutputData(LPCH buffer, DWORD size)
{
	DWORD i, j, row = 0;

	for (i=0; i<size; i++)
	{
		printf("  %-4.4x:  ", row * 16);

		for (j=0; j<ELEMENTS_IN_ROW; j++)
		{
			if ((j % 4 == 0) && (j != 0)) printf("| ");
			printf("%02.2X ", (unsigned char)buffer[i * ELEMENTS_IN_ROW + j]);
		}
		
		printf("\n");
		row++;
	}

	printf("\n");
}


//
//	OutputData(LPCH buffer, DWORD dataElements)
//
//	Outputs the MBR data for the user. User can also select the combination of 
//	the data parts to output using different flags stated at the beginning of 
//	this program. The data is printed according to the combination of bits 
//	activated by different flags.
//
//	Data selector bits:
//		1  - Code
//		2  - Disk Signature
//		4  - Nulls
//		8  - Primary partitions
//		16 - MBR Signature
//
//		31 - All
VOID OutputData(LPCH buffer, DWORD dataElements)
{
	UMBRCS bufToStruct;

	DWORD i, j;

	bufToStruct.buffer = buffer;

	// First output the code
	if ((dataElements & deCode) == deCode)
	{
		printf("Code (%d bytes):\n", SIZE_CODE);
		RawOutputData(buffer, SIZE_CODE / 16);
	}

	// Then comes the disk signature (optional)
	if ((dataElements & deDiskSignature) == deDiskSignature)
	{
		printf("Disk signature (%d bytes):\t", SIZE_DISK_SIGNATURE, " ");
		
		for (i=0; i<SIZE_DISK_SIGNATURE; i++)
			printf(" %02.2X", (unsigned char)bufToStruct.structure->seDiskSignature[i]);

		printf("\n\n");
	}

	// Then come the nulls (optional)
	if ((dataElements & deNulls) == deNulls)
	{
		printf("Nulls (%d bytes):\t\t", SIZE_NULLS, " ");
		
		for (i=0; i<SIZE_NULLS; i++)
			printf(" %02.2X", (unsigned char)bufToStruct.structure->seNulls[i]);

		printf("\n\n");
	}

	// Then comes the primary partitions table (optional)
	if ((dataElements & dePrimaryPartitions) == dePrimaryPartitions)
	{
		printf("Primary partitions (%d bytes):\n", SIZE_PRIMARY_PARTITIONS);
		
		for (i=0; i<SIZE_PRIMARY_PARTITIONS / 16; i++)
		{
			printf("  Partition %d:", i + 1);
			for (j=0; j<16; j++)
				printf(" %02.2X", (unsigned char)bufToStruct.structure->sePrimaryPartitions[i * 16 + j]);
			printf("\n");
		}

		printf("\n");
	}

	// Then comes the MBR signature
	if ((dataElements & deMBRSignature) == deMBRSignature)
	{
		printf("MBR signature (%d bytes):\t", SIZE_MBR_SIGNATURE);
		
		for (i=0; i<SIZE_MBR_SIGNATURE; i++)
		{
			printf(" %02.2X", (unsigned char)bufToStruct.structure->seMBRSignature[i]);
		}

		printf("\n\n");
	}
}

//
//	DWORD PrintToFile(LPCH buffer, DWORD dataElements, char *fileName)
//
//	Outputs the MBR section to a file in the binary mode. Can be used for 
//	making MBR backup copies. The same flags apply as in the OutputData 
//	function case.
//
//	Parameters:
//		LPCH buffer				- Pointer to the page holding the data
//		DWORD dataElements		- What data should be outputted to the file
//		PCHAR fileName			- The file name and path for the output
//
//	Return value:				- 0 on success, -1 on failure
//
//	TODO:
//		- fwrite test for errors - compare bytes to write and written bytes
//		- when writing only some pieces of code, align them properly, possibly
//			with null bytes where the data isn't requested to be written to file
DWORD PrintToFile(LPCH buffer, DWORD dataElements, PCHAR fileName)
{
	UMBRCS bufToStruct;
	FILE *lpFile;
	CHAR file_path[MAX_PATH_LENGTH];
	DWORD iRes = 0;
	
	bufToStruct.buffer = buffer;
	
	// Open the file for writing
	iRes = fopen_s(&lpFile, fileName, "wb");

	if (iRes != 0)
	{
		fprintf(stderr, "ERROR: fopen_s function failed, error no %d:\n\t%s\n\n", iRes, fileName);
		return -1;
	}


	// First output the code
	if ((dataElements & deCode) == deCode)
	{
		fwrite(bufToStruct.structure->seCode, 1, SIZE_CODE, lpFile);
	}

	// Then comes the disk signature (optional)
	if ((dataElements & deDiskSignature) == deDiskSignature)
	{
		fwrite(bufToStruct.structure->seDiskSignature, 1, SIZE_DISK_SIGNATURE, lpFile);
	}

	// Then come the nulls (optional)
	if ((dataElements & deNulls) == deNulls)
	{
		fwrite(bufToStruct.structure->seNulls, 1, SIZE_NULLS, lpFile);
	}

	// Then comes the primary partitions table (optional)
	if ((dataElements & dePrimaryPartitions) == dePrimaryPartitions)
	{
		fwrite(bufToStruct.structure->sePrimaryPartitions, 1, SIZE_PRIMARY_PARTITIONS, lpFile);
	}

	// Then comes the MBR signature
	if ((dataElements & deMBRSignature) == deMBRSignature)
	{
		fwrite(bufToStruct.structure->seMBRSignature, 1, SIZE_MBR_SIGNATURE, lpFile);
	}

	fclose(lpFile);

	GetFullPathNameA(fileName, MAX_PATH_LENGTH, file_path, NULL);
	printf("MBR is successfully stored in file: \n\n%s\n\n", file_path);

	return 0;
}

//
//	DWORD WriteMBR(LPCH buffer, HANDLE hVolume, DWORD dwBufferSize, DWORD dataElements, PCHAR fileName)
//
//	Writes a binary file to the desired MBR section. It is possible to write only some pieces of the data,
//	but they must be properly aligned as in the MBR definition. 
//
//	Parameters:
//		LPCH buffer				- Pointer to the page holding the data
//		DWORD dwBufferSize		- Length of the buffer to write
//		DWORD dataElements		- What data should be inputted from the file
//		PCHAR fileName			- The file name and path for the input
//
//	Return value:				- 0 on success, -1 on failure
//
DWORD WriteMBR(LPCH buffer, HANDLE hVolume, DWORD dwBufferSize, DWORD dataElements, PCHAR fileName)
{
	UMBRCS bufToStruct;
	DWORD dwBytesWritten;
	FILE *lpFile;
	DWORD iRes = 0;
	CHAR file_path[MAX_PATH_LENGTH];
	
	bufToStruct.buffer = buffer;

	//
	// First read the data to be written from a file
	//
	iRes = fopen_s(&lpFile, fileName, "rb");

	if (iRes != 0)
	{
		fprintf(stderr, "ERROR: fopen_s function failed, error no %d:\n\t%s\n\n", iRes, fileName);
		return -1;
	}

	//
	// Edit the contents of the original buffer by directly reading from file
	// and rewriting the desired contents.
	//
	// First output the code
	if ((dataElements & deCode) == deCode)
	{
		fread(bufToStruct.structure->seCode, 1, SIZE_CODE, lpFile);
	}
	else
	{
		fseek(lpFile, SIZE_CODE, SEEK_CUR);
	}

	// Then comes the disk signature (optional)
	if ((dataElements & deDiskSignature) == deDiskSignature)
	{
		fread(bufToStruct.structure->seDiskSignature, 1, SIZE_DISK_SIGNATURE, lpFile);
	}
	else
	{
		fseek(lpFile, SIZE_DISK_SIGNATURE, SEEK_CUR);
	}

	// Then come the nulls (optional)
	if ((dataElements & deNulls) == deNulls)
	{
		fread(bufToStruct.structure->seNulls, 1, SIZE_NULLS, lpFile);
	}
	else
	{
		fseek(lpFile, SIZE_NULLS, SEEK_CUR);
	}

	// Then comes the primary partitions table (optional)
	if ((dataElements & dePrimaryPartitions) == dePrimaryPartitions)
	{
		fread(bufToStruct.structure->sePrimaryPartitions, 1, SIZE_PRIMARY_PARTITIONS, lpFile);
	}
	else
	{
		fseek(lpFile, SIZE_PRIMARY_PARTITIONS, SEEK_CUR);
	}

	// Then comes the MBR signature
	if ((dataElements & deMBRSignature) == deMBRSignature)
	{
		fread(bufToStruct.structure->seMBRSignature, 1, SIZE_MBR_SIGNATURE, lpFile);
	}
	else
	{
		fseek(lpFile, SIZE_MBR_SIGNATURE, SEEK_CUR);
	}


	// We need to reset the file pointer before writing
	iRes = SetFilePointer(hVolume, 0, NULL, FILE_BEGIN);

	if (iRes == INVALID_SET_FILE_POINTER)
	{
		// ERROR:
		fprintf(stderr, "ERROR: SetFilePointer function failed, error no %d\n", GetLastError());

		// Releasing the resources
		fclose(lpFile);

		return -1;
	}

	//
	// Writing the changes to the volume. The whole local MBR is written to the disk, so
	// that the WriteFile does not complain about aligns.
	//
	iRes = WriteFile(hVolume, buffer, dwBufferSize, &dwBytesWritten, NULL);

	if (iRes == 0)
	{
		// ERROR:
		fprintf(stderr, "ERROR: WriteFile function failed, error no %d\n", GetLastError());

		// Releasing the resources
		fclose(lpFile);
		return -1;
	}

	
	GetFullPathNameA(fileName, MAX_PATH_LENGTH, file_path, NULL);

	printf("MBR is successfully rewritten from file: \n\n%s\n\n", file_path);

	// Releasing the resources
	fclose(lpFile);

	return 0;
}

//
// void PrintUsage()
//
// Outputs the program usage.
void PrintUsage()
{
	fprintf(stderr, "%s", helpText);
}

#include <windows.h>
#include <stdio.h>
#include <conio.h>
#include <WinIoCtl.h>

//
// Function definitions
//
LPCH ReadMBR(LPCH buffer, LPCH DeviceName, HANDLE hVolume, PDWORD dwBytesRead, PDWORD dwBufferSize);
DWORD WriteMBR(LPCH buffer, HANDLE hVolume, DWORD dwBufferSize, DWORD dataElements, PCHAR fileName);
DWORD PrintToFile(LPCH buffer, DWORD dataElements, PCHAR fileName);
VOID OutputData(LPCH buffer, DWORD dataElements);
VOID RawOutputData(LPCH buffer, DWORD size);
VOID PrintUsage();

//
// MBR data elements sizes
//
static const DWORD SIZE_MBR = 512;
static const DWORD SIZE_CODE = 440;
static const DWORD SIZE_DISK_SIGNATURE = 4;
static const DWORD SIZE_NULLS = 2;
static const DWORD SIZE_PRIMARY_PARTITIONS = 64;
static const DWORD SIZE_MBR_SIGNATURE = 2;

//
// Different data parts from MBR. "ALL_DATA" is consisted from all
// the "de*" bits (all the values are OR-ed together): 
// ALL_DATA = deCode | deDiskSignature | deNulls | dePrimaryPartitions | deMBRSignature
//
static const DWORD ALL_DATA = 31;

static const DWORD deCode = 1;
static const DWORD deDiskSignature = 2;
static const DWORD deNulls = 4;
static const DWORD dePrimaryPartitions = 8;
static const DWORD deMBRSignature = 16;

//
// Other constants
//
static const DWORD ELEMENTS_IN_ROW = 16;
static const DWORD MAX_PATH_LENGTH = 1024;

//
// Structure representing MBR fields
//
typedef struct _sMBR
{
	char seCode[SIZE_CODE];
	char seDiskSignature[SIZE_DISK_SIGNATURE];
	char seNulls[SIZE_NULLS];
	char sePrimaryPartitions[SIZE_PRIMARY_PARTITIONS];
	char seMBRSignature[SIZE_MBR_SIGNATURE];
} SMBR, *LPSMBR;

//
// Union that converts one long char buffer to a MBR structure
//
typedef union _bufToStruct
{
	LPCH buffer;
	LPSMBR structure;
} UMBRCS, *LPUMBRCS;

//
// Output texts
//
static const char *helpText = 
" Usage:\n"
"\n"
"\nAction:\n\n"
"  When no flags are selected, the MBR contents are printed to the screen in\n"
"  a human-readable format.\n\n"
"    -r [a]    - Read MBR from a device to a file, argument is the file name\n"
"    -w [a]    - Write MBR from a file to a device, argument is the file name\n"
"\nData:\n\n"
"  Use these flags to select only particular data to print, read or write to\n"
"  file. Several flags can be selected, all the flags are selected by default.\n\n"
"    -c        - Code\n"
"    -d        - Disk signature\n"
"    -n        - Nulls\n"
"    -p        - Primary partitions table\n"
"    -m        - MBR Signature\n"
"\nOther:\n\n"
"  When defining a disk bootloader, use the drive letter without trailing\n"
"  backslash, for instance, use \"C:\" instead of \"C:\\\".\n\n"
"    -v [a]    - Device, without this flag, \"PhysicalDrive0\" is used\n"
"    -b [ao]   - Binary output / raw output, optional argument is the length\n"
"                of raw output, default is 512 bytes.\n"
"    -h        - Print this help\n";

static const char *intro = 
"\n==================\n"
"    MBR Editor\n"
"==================\n\n"
"Created by:  Nutcracker from www.criticalsecurity.net\n"
"Date:        13.03.2010.\n"
"Version:     v1.0\n\n";

last pid: 8400; load averages: 1.23, 1.18, 1.23 up 16+00:47:39 11:59:27
64 processes: 2 running, 62 sleeping

Mem: 195M Active, 857M Inact, 198M Wired, 112M Buf, 752M Free
Swap: 4070M Total, 4070M Free


PID USERNAME THR PRI NICE SIZE RES STATE C TIME WCPU COMMAND
95241 root 1 121 0 1960K 1152K RUN 0 947:15 96.29% zip
8398 root 1 4 0 4868K 3116K sbwait 0 0:00 1.00% sshd
898 mysql 14 20 0 523M 144M kserel 0 25:59 0.00% mysqld
700 root 1 8 0 19036K 11952K nanslp 0 0:24 0.00% httpd
724 root 1 96 0 3484K 3012K select 0 0:19 0.00% sendmail
713 root 1 122 0 3524K 2704K select 0 0:14 0.00% sshd
44526 www 1 4 0 21964K 15588K accept 0 0:05 0.00% httpd
48948 www 1 4 0 22844K 16200K accept 0 0:04 0.00% httpd
74517 www 1 4 0 21964K 15284K accept 0 0:04 0.00% httpd
552 root 1 96 0 1376K 1032K select 0 0:03 0.00% syslogd
80513 www 1 4 0 21836K 15432K accept 0 0:03 0.00% httpd
270 _dhcp 1 96 0 1464K 1148K select 0 0:03 0.00% dhclient
748 root 1 8 0 1404K 1116K nanslp 0 0:03 0.00% cron
92499 www 1 4 0 21984K 15624K accept 0 0:03 0.00% httpd
2881 www 1 4 0 21804K 15112K accept 0 0:01 0.00% httpd
95197 www 1 4 0 21144K 14476K accept 0 0:01 0.00% httpd
654 root 1 96 0 1288K 824K select 0 0:01 0.00% usbd
3015 www 1 4 0 21956K 15524K accept 0 0:01 0.00% httpd

# Example MySQL config file for large systems.
#
# This is for a large system with memory = 512M where the system runs mainly
# MySQL.
#
# You can copy this file to
# /etc/my.cnf to set global options,
# mysql-data-dir/my.cnf to set server-specific options (in this
# installation this directory is /var/db/mysql) or
# ~/.my.cnf to set user-specific options.
#
# In this file, you can use all long options that a program supports.
# If you want to know which options a program supports, run the program
# with the "--help" option.

# The following options will be passed to all MySQL clients
[client]
#password = your_password
port = 3306
socket = /tmp/mysql.sock

# Here follows entries for some specific programs

# The MySQL server
[mysqld]
port = 3306
socket = /tmp/mysql.sock
skip-locking
key_buffer = 512M
max_allowed_packet = 2M
table_cache = 1024
sort_buffer_size = 8M
read_buffer_size = 128M
read_rnd_buffer_size = 8M
myisam_sort_buffer_size = 128M
thread_cache_size = 8
query_cache_size= 128M
# Try number of CPU's*2 for thread_concurrency
thread_concurrency = 8

# Don't listen on a TCP/IP port at all. This can be a security enhancement,
# if all processes that need to connect to mysqld run on the same host.
# All interaction with mysqld must be made via Unix sockets or named pipes.
# Note that using this option without enabling named pipes on Windows
# (via the "enable-named-pipe" option) will render mysqld useless!
#
#skip-networking

# Disable Federated by default
skip-federated

# Replication Master Server (default)
# binary logging is required for replication
log-bin=mysql-bin

# required unique id between 1 and 2^32 - 1
# defaults to 1 if master-host is not set
# but will not function as a master if omitted
server-id = 1

# Replication Slave (comment out master section to use this)
#
# To configure this host as a replication slave, you can choose between
# two methods :
#
# 1) Use the CHANGE MASTER TO command (fully described in our manual) -
# the syntax is:
#
# CHANGE MASTER TO MASTER_HOST=<host>, MASTER_PORT=<port>,
# MASTER_USER=<user>, MASTER_PASSWORD=<password> ;
#
# where you replace <host>, <user>, <password> by quoted strings and
# <port> by the master's port number (3306 by default).
#
# Example:
#
# CHANGE MASTER TO MASTER_HOST='125.564.12.1', MASTER_PORT=3306,
# MASTER_USER='joe', MASTER_PASSWORD='secret';
#
# OR
#
# 2) Set the variables below. However, in case you choose this method, then
# start replication for the first time (even unsuccessfully, for example
# if you mistyped the password in master-password and the slave fails to
# connect), the slave will create a master.info file, and any later
# change in this file to the variables' values below will be ignored and
# overridden by the content of the master.info file, unless you shutdown
# the slave server, delete master.info and restart the slaver server.
# For that reason, you may want to leave the lines below untouched
# (commented) and instead use CHANGE MASTER TO (see above)
#
# required unique id between 2 and 2^32 - 1
# (and different from the master)
# defaults to 2 if master-host is set
# but will not function as a slave if omitted
#server-id = 2
#
# The replication master for this slave - required
#master-host = <hostname>
#
# The username the slave will use for authentication when connecting
# to the master - required
#master-user = <username>
#
# The password the slave will authenticate with when connecting to
# the master - required
#master-password = <password>
#
# The port the master is listening on.
# optional - defaults to 3306
#master-port = <port>
#
# binary logging - not required for slaves, but recommended
#log-bin=mysql-bin

# Point the following paths to different dedicated disks
#tmpdir = /tmp/
#log-update = /path-to-dedicated-directory/hostname

# Uncomment the following if you are using BDB tables
#bdb_cache_size = 64M
#bdb_max_lock = 100000

# Uncomment the following if you are using InnoDB tables
#innodb_data_home_dir = /var/db/mysql/
#innodb_data_file_path = ibdata1:10M:autoextend
#innodb_log_group_home_dir = /var/db/mysql/
#innodb_log_arch_dir = /var/db/mysql/
# You can set .._buffer_pool_size up to 50 - 80 %
# of RAM but beware of setting memory usage too high
#innodb_buffer_pool_size = 256M
#innodb_additional_mem_pool_size = 20M
# Set .._log_file_size to 25 % of buffer pool size
#innodb_log_file_size = 64M
#innodb_log_buffer_size = 8M
#innodb_flush_log_at_trx_commit = 1
#innodb_lock_wait_timeout = 50

[mysqldump]
quick
max_allowed_packet = 16M

[mysql]
no-auto-rehash
# Remove the next comment character if you are not familiar with SQL
#safe-updates

[isamchk]
key_buffer = 128M
sort_buffer_size = 128M
read_buffer = 2M
write_buffer = 2M

[myisamchk]
key_buffer = 128M
sort_buffer_size = 128M
read_buffer = 2M
write_buffer = 2M

[mysqlhotcopy]
interactive-timeout