main.cpp

ActiveX Setup Server Version 2.0.5 Chipsbrain Engineer Final Release

/*
 * main.cpp
 */

static const char version[] = "setupserv: v2.0.5 (C) 2005 Chipsbrain Co., Ltd.\n";

#include <stdio.h>
#include <signal.h>
#include <string.h>
#include <unistd.h>
#include <unistd.h>	// fork()
#include <sys/types.h>
#include <sys/wait.h>	// waitpid()
#include <sys/socket.h>	// recv(), send()

#include <sys/ipc.h>
#include <sys/msg.h>	// message queue

#include <errno.h>
#include <sys/ioctl.h>

#include "def.h"
#include "net.h"
#include "debug.h"
#include "mjpeg_drv.h"
#include "account.h"
//#include "saa7113h.h" 	/* saa7113h ioctl */

//#define DEBUG

#ifdef DEBUG
#define pdebug(fmt,args...)	fprintf(stderr, fmt, ## args)
#else
#define pdebug(fmt,args...)	do{  } while(0)
#endif

// functions...
static void Terminate(int iSigNo);
bool Init();
bool ResetSocket();
int Run(int sock);
RESULT DoLogin(CAccount * pAccount, int sock);
/*
RESULT DoUserList(CAccount * pAccount);
RESULT DoAddUser(CAccount * pAccount);
RESULT DoDelUser(CAccount * pAccount);
RESULT DoPasswd(CAccount * pAccount);
*/
RESULT DoYuvFormat(CAccount * pAccount, int sock);
RESULT DoVideoQuality(CAccount * pAccount, int scok);
RESULT DoVideoOption(CAccount * pAccount, int sock);
RESULT DoJpegRotate(CAccount * pAccount, int sock);
RESULT DoJpegBright(CAccount * pAccount, int sock);
RESULT DoJpegContrast(CAccount * pAccount, int sock);
RESULT DoCameraMount(CAccount * pAccount, int sock);
RESULT DoCameraAssemble(CAccount * pAccount, int sock);
/*
RESULT DoFtpAddr(CAccount * pAccount);
RESULT DoEmailAddr(CAccount * pAccount);
RESULT DoIpAddr(CAccount * pAccount);
RESULT DoPortNum(CAccount * pAccount);
RESULT DoNetmaskAddr(CAccount * pAccount);
RESULT DoGatewayAddr(CAccount * pAccount);
RESULT DoDnsAddr(CAccount * pAccount);
*/

// global variable...
CSock g_Sock;
#ifdef USE_MJPEG_DRIVER
CMjpegDriver g_MjpegDrv;
#endif

//int g_saa_driver;

//#define MAX_TEXT	512

struct msg_st {
	long int msg_type;
	char data;
};

int g_msgid;

static char g_camtype = 0;

int main(int argc, char * argv[])
{
	int sock;
	pid_t pid = (pid_t) 0;
	static int iConnNum = 0;
	COMMAND cmd;

	//OutputDebugString(sizeof(FTP_INFO));
	
	printf("%s", version);
	
	// IPC
	g_msgid = msgget((key_t)1000, 0666 | IPC_CREAT);

	if(g_msgid == -1) {
		fprintf(stderr, "msgget failed with error: %d\n", errno);
		return -1;
	}

	if(!Init()){
		OutputDebugString("Initialize failure!!!");
		return -1;
	}
	
	OutputDebugString(DF_START_MSG, "(Exit: Ctrl + Z)");

	while(1){
		sock = g_Sock.Accept();
		//if(g_Sock.Accept() != -1){
		if(sock != -1) {
			pdebug("accept()\n");
			if (pid != (pid_t) 0) {
				if (waitpid(pid, NULL, WNOHANG) > 0) {
					iConnNum--;
					pdebug("exited pid %d, iConnNum %d\n", pid, iConnNum);
					pid = (pid_t) 0;
				}
			}

			if (iConnNum > 0) {
				pdebug("connection number excess! %d\n", iConnNum);
				//cmd = FAIL;
				cmd = PERMISSION_EXCESS;
				if(g_Sock.Send((char *)&cmd, sizeof(COMMAND)) == -1)
					perror("send()");
				continue;
			}

			pid = fork();
			if(pid < 0) {
				// error
				perror("fork");
				g_Sock.Close(); // close socket
				exit(1);
			} else if(pid == 0) {
				// child process
				pdebug("child process creation\n");
				if(Run(sock) == -1){
					/*
					if(!ResetSocket()){
						OutputDebugString("There is fatal problem. Plese reboot system...");
						_exit(-1);
					}
					*/
					pdebug("run(): socket failed\n");
				}
				//g_Sock.Close();
				pdebug("socket close and child process destruction\n");
				exit(0);
			} else {
				// parent process
				iConnNum++;

				if (waitpid(pid, NULL, WNOHANG) > 0) {
					iConnNum--;
					pdebug("exited pid %d, iConnNum %d\n", pid, iConnNum);
					pid = (pid_t) 0;
				}

			}
		}
		else{
			if(!ResetSocket()){
				OutputDebugString("There is fatal problem. Plese reboot system...");
				pdebug("There is fatal problem. Plese reboot system...\n");
				_exit(-1);
			}
		}
	}

	return 0;
}

bool ResetSocket()
{
	int iSleepTime = 1;

	pdebug("socket reset\n");
	g_Sock.Disconnect();
	do{
		iSleepTime <<= 1;
		if(iSleepTime > 60)
			return false;
		sleep(iSleepTime);
	}while(!g_Sock.Init(DF_SETUP_PORT));

	return true;
}

bool Init()
{
	// signal init...
	if(signal(SIGTSTP, Terminate) == SIG_ERR)
		return false;
	
	// socket init...
	if(!g_Sock.Init(DF_SETUP_PORT))
		return false;
#ifdef USE_MJPEG_DRIVER
	// mjpeg dirver init...
	if(!g_MjpegDrv.Open(DF_MJPEG_DEVICE_DRIVER_PATH))
		return false;
//	g_MjpegDrv.Reset();
#endif
	/*
	g_saa_driver = open(DF_MJPEG_DEVICE_DRIVER_PATH, O_RDONLY);
	if(g_saa_driver < 0) {
		fprintf(stderr, "can't open /dev/saa");
		return false;
	}
	*/

	return true;
}

static void Terminate(int iSigNo)
{
	// socket close...
	g_Sock.Disconnect();
#ifdef USE_MJPEG_DRIVER
	// mjpeg device driver close...
	g_MjpegDrv.Stop();
	g_MjpegDrv.Close();
#endif
	//close(g_saa_driver);

	OutputDebugString(DF_END_MSG);
	_exit(1);
}

int Run(int sock)
{
	CAccount Account;
	bool bExit = false;
	COMMAND cmd = NOTHING;
	unsigned int delay = 0;
	RESULT (* pf)(CAccount *, int);
	int ret = -1;

	while(!bExit){
		//ret = g_Sock.Recv(&cmd, sizeof(COMMAND), MSG_DONTWAIT);
		ret = recv(sock, &cmd, sizeof(COMMAND), MSG_NOSIGNAL|MSG_DONTWAIT);
		// for Debug
		if (ret > 0)
			pdebug("cmd: %02x\n", cmd);
		// end Debug
		
		switch(cmd)
		{
		case LOGIN:
			OutputDebugString("***login***");
			pf = DoLogin;
			break;
		/*
		case USER_LIST:
			OutputDebugString("***user list***");
			pf = DoUserList;
			break;
		case ADDUSER:
			OutputDebugString("***adduser***");
			pf = DoAddUser;
			break;
		case DELUSER:
			OutputDebugString("***deluser***");
			pf = DoDelUser;
			break;
		case PASSWD:
			OutputDebugString("***passwd***");
			pf = DoPasswd;
			break;
		*/
		//case YUV_FORMAT:
		case VIDEO_MODE:
			OutputDebugString("***yuv format***");
			pdebug("***yuv format***\n");
			pf = DoYuvFormat;
			break;
		case VIDEO_QUALITY:
			OutputDebugString("***video quality***");
			pf = DoVideoQuality;
			break;
		case VIDEO_OPTION:
			OutputDebugString("***video option***");
			pf = DoVideoOption;
			break;
		case JPEG_ROTATE:
			pf = DoJpegRotate;
			break;
		case VIDEO_BRIGHT:
			pf = DoJpegBright;
			break;
		case VIDEO_CONTRAST:
			pf = DoJpegContrast;
			break;
		case CAM_MOUNT:
			pf = DoCameraMount;
			break;
		case CAM_ASSEMBLE:
			pf = DoCameraAssemble;
			break;
		/*
		case FTP_ADDR:
			OutputDebugString("***ftp addr***");
			pf = DoFtpAddr;
			break;
		case EMAIL_ADDR:
			OutputDebugString("***email addr***");
			pf = DoEmailAddr;
			break;
		case IP_ADDR:
			OutputDebugString("***ip addr***");
			pf = DoIpAddr;
			break;
		case PORT_NUM:
			OutputDebugString("***port num***");
			pf = DoPortNum;
			break;
		case NETMASK_ADDR:
			OutputDebugString("***netmask addr***");
			pf = DoNetmaskAddr;
			break;
		case GATEWAY_ADDR:
			OutputDebugString("***gateway addr***");
			pf = DoGatewayAddr;
			break;
		case DNS_ADDR:
			OutputDebugString("***dns addr***");
			pf = DoDnsAddr;
			break;
		*/
		case DISCONNECT:
			OutputDebugString("***disconnect***");
			pdebug("disconnect***\n");
			bExit = true;
			goto _final;
			break;
			//continue;
		case NOTHING:
		default:
			usleep(100);
			delay += 100;
			if(delay > DF_NO_OPER_LIMIT){
				OutputDebugString("time out.");
				pdebug("timeout\n");
				bExit = true;
				//break;
				//continue;
			}
			//pdebug("%d: %d\n", DF_NO_OPER_LIMIT, delay);
			goto _final;
			break;
			//continue;
		}

		switch((*pf)(&Account, sock))
		{
		case _ok:
			OutputDebugString("_ok");
			pdebug("_ok\n");
			break;
		case _success:
			OutputDebugString("_success");
			pdebug("_success\n");
			cmd = SUCCESS;
			//if(g_Sock.Send((char *)&cmd, sizeof(COMMAND)) == -1)
			if(send(sock, (char *)&cmd, sizeof(COMMAND), MSG_NOSIGNAL) == -1)
				goto _socket_failed;
			break;
		case _failed:
		case _permdeny:
			OutputDebugString("_failed");
			pdebug("_failed\n");
			cmd = FAIL;
			//if(g_Sock.Send((char *)&cmd, sizeof(COMMAND)) == -1)
			if(send(sock, (char *)&cmd, sizeof(COMMAND), MSG_NOSIGNAL) == -1)
				goto _socket_failed;
			break;
		case _sockfail:
_socket_failed:
			Perror("socket failure : ");
		case _reset:
			Account.Reset();
			OutputDebugString("_reset: end job...");
			pdebug("_reset: end job...\n");
			close(sock);
			return -1;
		default:
			break;
		}
		delay = 0;
_final:
		cmd = NOTHING;
	}
	Account.Reset();
	OutputDebugString("end job...");
	pdebug("end job...\n");
	close(sock);
	return 0;
}

RESULT DoLogin(CAccount * pAccount, int sock)
{
	PARAMETER param;
	PERMISION user_permision;

	memset(&param, 0, sizeof(PARAMETER));
	//if(g_Sock.Recv((char *)&param, sizeof(PARAMETER)) == -1)
	if(recv(sock, (char *)&param, sizeof(PARAMETER), MSG_NOSIGNAL) == -1) {
		pdebug("DoLogin(): recv failed\n");
		return _sockfail;
	}
	pdebug("%s, %s\n", param.index[0], param.index[1]);
	user_permision = pAccount->UserAuthenticate(param.index[0], param.index[1]);
	if(user_permision != PERMISION_ADMIN) {
		OutputDebugString("no root account");
		user_permision = PERMISION_DENY;
	}
	//if(g_Sock.Send((char *)&user_permision, sizeof(PERMISION)) == -1)
	if(send(sock, (char *)&user_permision, sizeof(PERMISION), MSG_NOSIGNAL) == -1)
		return _sockfail;

	return _ok;
}

/*