main.c

uClinux下用的数据库

void usage()
{
	printf("Usage :  msql2d [-f ConfFile]\n\n");
}






#define STRN_CPY(d,s,l)   { strncpy((d),(s),(l)); (d)[(l)-1] = 0; }
#define STR_NE(x,y)       (strcasecmp((x),(y)) != 0)
#define STRING_LENGTH     128
   


RETSIGTYPE childHandler(sig)
	int	sig;
{
	int	clientSock;

	signal(SIGCHLD,SIG_IGN);
	printf("\n\nBackend process exited!  Terminating server.\n");
	clientSock = 3;
	while(clientSock < maxCons + globalServer->config.cacheDescriptors)
	{
		if (globalServer->conArray[clientSock].db)
		{
			printf("Forcing close on Socket %d\n",clientSock);
			shutdown(clientSock,2);
			close(clientSock);
		}
		clientSock++;
	}
	if (globalServer->unixSock >= 0)
	{
		shutdown(globalServer->unixSock,2);
		close(globalServer->unixSock);
		unlink(globalServer->unixPort);
		free(globalServer->unixPort);
	}
	/*
	** Close off the children
	*/
	sync();
	fprintf(stderr,"Closing backend connections.\n\n");
	printf("\n");
	exit(1);
}


RETSIGTYPE sigTrap(sig)
	int	sig;
{
	int	clientSock;

#ifdef WIN32
	fprintf(stderr,"\nHit by signal\n\n");
#else
	signal(sig,SIG_IGN);
	fprintf(stderr,"\nHit by a sig %d\n\n",sig);
#endif
	clientSock = 3;
	msqlDebug0(MOD_ANY,"Forced server shutdown due to bad signal!\n");
	while(clientSock < maxCons + globalServer->config.cacheDescriptors)
	{
		if (globalServer->conArray[clientSock].db)
		{
			printf("Forcing close on Socket %d\n",clientSock);
			shutdown(clientSock,2);
			close(clientSock);
		}
		clientSock++;
	}
	if (globalServer->unixSock >= 0)
	{
		shutdown(globalServer->unixSock,2);
		close(globalServer->unixSock);
		unlink(globalServer->unixPort);
		free(globalServer->unixPort);
	}
	/*
	** Close off the children
	*/
	sync();
	fprintf(stderr,"Closing backend connections.\n\n");
	printf("\n");
	abort();
}




void setupSignals()
{
#ifdef SIGSEGV
	signal(SIGSEGV,sigTrap);
#endif
#ifdef SIGBUS
	signal(SIGBUS,sigTrap);
#endif
#ifdef SIGINT
	signal(SIGINT,puntServer);
#endif
#ifdef SIGQUIT
	signal(SIGQUIT,puntServer);
#endif
#ifdef SIGKILL
	signal(SIGKILL,puntServer);
#endif
#ifdef SIGPIPE
	signal(SIGPIPE,puntClient);
#endif
#ifdef SIGTERM
	signal(SIGTERM,puntServer);
#endif
#ifdef SIGHUP
	signal(SIGHUP,SIG_IGN);
#endif
/*
#ifdef SIGCHLD
	signal(SIGCHLD,childHandler);
#endif
*/
}


void processClientRequest(server, client)
	msqld		*server;
	int		client;
{
	mQuery_t	*query,
			dummyQuery;
	int		clientCommand,
			comSock;
	char		dbname[255],
			*arg, *arg2,
			*cp,
			tmpChar;



	comSock = server->conArray[client].sock;
	if (netReadPacket(comSock) <= 0)
	{
		msqlDebug1(MOD_GENERAL,"Command read on sock %d failed!\n",
			comSock);
		clientCommand = QUIT;
	}
	else
	{
		clientCommand = atoi(packet);
	}
	msqlDebug3(MOD_GENERAL,"Command on sock %d = %d (%s)\n", comSock, 
		clientCommand, comTable[clientCommand]);

	switch(clientCommand)
	{
		case QUIT:
			msqlDebug0(MOD_GENERAL,"DB QUIT!\n");
			FD_CLR(comSock,&server->clientFDs);
			shutdown(comSock,2);
			close(comSock);
			if(server->conArray[client].user)
			{
				free(server->conArray[client].user);
				server->conArray[client].user = NULL;
			}
			if(server->conArray[client].host)
			{
				free(server->conArray[client].host);
				server->conArray[client].host = NULL;
			}
			if(server->conArray[client].db)
			{
				free(server->conArray[client].db);
				server->conArray[client].db = NULL;
			}
			server->conArray[client].sock = -1;
			numCons--;
			break;

		case INIT_DB:
			cp=(char *)strtok(packet+2,"\n\r");
			if (!cp)
			{
				netError(comSock,NO_DB_ERROR);
				break;
			}
			strcpy(dbname,cp);
			msqlDebug1(MOD_GENERAL,"DBName = %s\n", dbname);
			if(server->conArray[client].db)
			{
				free(server->conArray[client].db);
				server->conArray[client].db = NULL;
			}
			server->conArray[client].db = (char *)strdup(dbname);
			if (utilCheckDB(server, dbname) < 0)
			{
				netError(comSock,errMsg);
				break;
			}
			netOK(comSock);
			break;

		case QUERY:
			if (!server->conArray[client].db)
			{
				netError(comSock,NO_DB_ERROR);
				break;
			}
			curSock = comSock;
			cp=(char *)(packet+2);
			arg = cp;
			tmpChar = 0;
			if (strlen(arg) > 4096)
			{
				tmpChar = *(arg+4096);
				*(arg+4096) = 0;
			}
			msqlDebug1(MOD_QUERY,"Query = %s",arg);

			if (tmpChar)
				*(arg+4096) = tmpChar;
			aclSetPerms(RW_ACCESS);
			query = parseQuery(server,arg, comSock, 
				server->conArray[client].user, 
				server->conArray[client].db);
			if (query)
			{
				processQuery(server, query, client, arg);
				parseCleanQuery(query);
			}
			break;

		case EXPLAIN:
			if (!server->conArray[client].db)
			{
				netError(comSock,NO_DB_ERROR);
				break;
			}
			curSock = comSock;
			cp=(char *)(packet+2);
			while(*cp != ':') cp++;
			arg = (char *)strdup(cp + 1);
			tmpChar = 0;
			if (strlen(arg) > 4096)
			{
				tmpChar = *(arg+4096);
				*(arg+4096) = 0;
			}
			msqlDebug1(MOD_QUERY,"Explain = %s",arg);
			if (tmpChar)
				*(arg+4096) = tmpChar;
			query = parseQuery(server, arg, comSock, 
				server->conArray[client].user, 
				server->conArray[client].db);
			if (query)
			{
				query->explainOnly = 1;
				processQuery(server, query, client, arg);
				parseCleanQuery(query);
			}
			if(arg)
				free(arg);
			break;

		case DB_LIST:
			curSock = comSock;
			processListDBs(server, comSock);
			break;

		case SEQ_INFO:
			if (!server->conArray[client].db)
			{
				netError(comSock,NO_DB_ERROR);
				break;
			}
			cp = (char *)index(packet,':');
			cp=(char *)strtok(cp+1, "\n\r");
			arg = (char *)strdup(cp);
			curSock = comSock;
			processSequenceInfo(server, comSock, arg, 
				server->conArray[client].db);
			if(arg)
				free(arg);
			break;

		case TABLE_LIST:
			if (!server->conArray[client].db)
			{
				netError(comSock, NO_DB_ERROR);
				break;
			}
			curSock = comSock;
			processListTables(server, comSock, 
				server->conArray[client].db);
			break;

		case FIELD_LIST:
			if (!server->conArray[client].db)
			{
				netError(comSock,NO_DB_ERROR);
				break;
			}
			cp=(char *)strtok(packet+2, "\n\r");
			arg = (char *)strdup(cp);
			curSock = comSock;
			processListFields(server, comSock, arg, 
				server->conArray[client].db);
			if(arg)
				free(arg);
			break;

		case INDEX_LIST:
			if (!server->conArray[client].db)
			{
				netError(comSock,NO_DB_ERROR);
				break;
			}
			cp=(char *)strtok(packet+2, ":\n\r");
			arg = (char *)strdup(cp);
			cp=(char *)strtok(NULL,"\n\r");
			arg2 = (char *)strdup(cp);
			curSock = comSock;
			processListIndex(server, comSock, arg2, arg, 
				server->conArray[client].db);
			if(arg)
				free(arg);
			if(arg2)
				free(arg2);
			break;

               	case EXPORT:
			if (!server->conArray[client].db)
			{
				netError(comSock,NO_DB_ERROR);
				break;
			}
			cp=(char *)strtok(packet+2, ":\n\r");
			arg = (char *)strdup(cp);
			cp=(char *)strtok(NULL,":\n\r");
			arg2 = (char *)strdup(cp);
			curSock = comSock;
			dummyQuery.curUser = server->conArray[client].user;
			dummyQuery.curDB = server->conArray[client].db;
			processExportTable(server, comSock, 
				server->conArray[client].db, arg, arg2, NULL);
			if(arg)
				free(arg);
			if(arg2)
				free(arg2);
			break;

		case CREATE_DB:
			if (!aclCheckLocal(&server->conArray[client]))
			{
				netError(comSock,PERM_DENIED_ERROR);
				break;
			}
			cp=(char *)strtok(packet+2, "\n\r");
			arg = (char *)strdup(cp);
			processCreateDB(server, comSock, arg);
			if(arg)
				free(arg);
			break;

	 	case COPY_DB:
			if (!aclCheckLocal(&server->conArray[client]))
			{
				netError(comSock,PERM_DENIED_ERROR);
				break;
			}
			cp=(char *)strtok(packet+2, ":\n\r");
			arg = (char *)strdup(cp);
			cp=(char *)strtok(NULL, "\n\r");
			arg2 = (char *)strdup(cp);
			processCopyDB(server, comSock,arg, arg2);
			if(arg)
				free(arg);
			if(arg2)
				free(arg2);
			break;

		case MOVE_DB:
			if (!aclCheckLocal(&server->conArray[client]))
			{
				netError(comSock,PERM_DENIED_ERROR);
				break;
			}
			cp=(char *)strtok(packet+2, ":\n\r");
			arg = (char *)strdup(cp);
			cp=(char *)strtok(NULL, "\n\r");
			arg2 = (char *)strdup(cp);
			processMoveDB(server, comSock,arg, arg2);
			if(arg)
				free(arg);
			if(arg2)
				free(arg2);
			break;

		case DROP_DB:	
			if (!aclCheckLocal(&server->conArray[client]))
			{
				netError(comSock,PERM_DENIED_ERROR);
				break;
			}
			cp=(char *)strtok(packet+2, "\n\r");
			arg = (char *)strdup(cp);
			processDropDB(server,comSock,arg);
			if(arg)
				free(arg);
			break;

		case RELOAD_ACL:
			if (!aclCheckLocal(&server->conArray[client]))
			{
				netError(comSock,PERM_DENIED_ERROR);
				break;
			}
			aclReloadFile(comSock);
			netEndOfList(comSock);
			break;


		case SHUTDOWN:
			if (!aclCheckLocal(&server->conArray[client]))
			{
				netError(comSock,PERM_DENIED_ERROR);
				break;
			}
			netEndOfList(comSock);
			puntServer(-1);
			exit(0);
			break;

		case SERVER_STATS:
			if (!aclCheckLocal(&server->conArray[client]))
			{
				netError(comSock,PERM_DENIED_ERROR);
				break;
			}
			sendServerStats(server,comSock);
			netEndOfList(comSock);
			break;

		default:
			netError(comSock, UNKNOWN_COM_ERROR);
			break;
	}
}


void debugTrap()
{
	/* We use this as a debugger breakpoint */
}

void childStartup()
{
	/* 
	** The broker code references this so we need an empty
	** function for the linker even though it'll never be called
	*/
}


int main(argc,argv)
	int	argc;
	char	*argv[];
{
	msqld	server;
	int	sock,
		newSock,
		maxSock,
		cacheSize,
		opt,
		error,
		errFlag = 0,
		count,
		c;
	char	*uname,
		path[MSQL_PATH_LEN],
		pidBuf[10];
	int	pidFD;
	fd_set	readFDs;

        extern  char *optarg;
#ifdef HAVE_SETRLIMIT
	struct	rlimit limit;
#endif
	struct	passwd *pwd;
	struct	stat sbuf;

#ifdef	DEBUG_BSD_MALLOC
	extern char *malloc_options;
	malloc_options = "AJ";
#endif
#ifdef 	DEBUG_MEMTRACE