util.c

网络数据管理协议的开发

/*                               -*- Mode: C -*- 
 * util.c
 * 
 * Description     : NDMP daemon utility functions.
 * 
 * Copyright (c) 1996,1997 PDC, Network Appliance. All Rights Reserved.
 *
 * $Id: util.c,v 1.9 1998/05/26 03:52:25 tim Exp $
 */

#if !defined(lint) && !defined(SABER)
static char rcsId[] __attribute__ ((unused)) = "@(#) $Id: util.c,v 1.9 1998/05/26 03:52:25 tim Exp $";
#endif

#include <stdlib.h>
#include <unistd.h>
#include <errno.h>
#include <string.h>

#include "ndmpd.h"

/*
 * ndmpdAddFileHandler
 *   Adds a file handler to the file handler list.
 *   The file handler list is used by ndmpdDispatch.
 *
 * Parameters:
 *   session (input) - session pointer.
 *   cookie  (input) - opaque data to be passed to file hander when called.
 *   fd      (input) - file descriptor.
 *   mode    (input) - bitmask of the following:
 *                     1 = watch file for ready for reading
 *                     2 = watch file for ready for writing
 *                     4 = watch file for exception
 *   class   (input) - handler class. (HC_CLIENT, HC_MOVER, HC_MODULE)
 *   func    (input) - function to call when the file meets one of the
 *                     conditions specified by mode.
 *
 * Returns:
 *   0 - success.
 *  -1 - error.
 */
int
ndmpdAddFileHandler(NdmpdSession*			session,
					void*					cookie,
					int						fd,
					u_long					mode,
					u_long					class,
					NdmpdFileHandlerFunc*	func)
{
	NdmpdFileHandler*		new;

	new = (NdmpdFileHandler*)malloc(sizeof(NdmpdFileHandler));
	if (new == 0)
	{
		Error(LOG_ERR,
			  "ndmpdAddFIleHandler: malloc error: %s.\n",
			  strerror(errno));
		return(-1);
	}

	new->cookie = cookie;
	new->fd     = fd;
	new->mode   = mode;
	new->class  = class;
	new->func   = func;
	new->next   = session->fileHandlerList;
	session->fileHandlerList = new;
	return(0);
}


/*
 * ndmpdRemoveFileHandler
 *   Removes a file handler from the file handler list.
 *
 * Parameters:
 *   session (input) - session pointer.
 *   fd      (input) - file descriptor.
 *
 * Returns:
 *   0 - success.
 *  -1 - error.
 */
int
ndmpdRemoveFileHandler(NdmpdSession*	session,
					   int				fd)
{
	NdmpdFileHandler**	last;
	NdmpdFileHandler*	handler;
	
	last = &session->fileHandlerList;
	while (*last != 0)
	{
		handler = *last;
		
		if (handler->fd == fd)
		{
			*last = handler->next;
			(void)free((void*)handler);
			return(1);
		}

		last = &handler->next;
	}

	return(0);
}


/*
 * ndmpdSelect
 *   Calls select on the the set of file descriptors from the
 *   file handler list masked by the fdClass argument.
 *   Calls the file handler function for each
 *   file descriptor that is ready for I/O.
 *
 * Parameters:
 *   session (input) - session pointer.
 *   block   (input) - if TRUE, ndmpdSelect waits until at least one
 *                     file descriptor is ready for I/O. Otherwise,
 *                     it returns immediately if no file descriptors are
 *                     ready for I/O.
 *   classMask (input) - bit mask of handler classes to be examined.
 *                     Provides for excluding some of the handlers from
 *                     being called.
 *
 * Returns:
 *  -1 - error.
 *   0 - no handlers were called.
 *   1 - at least one handler was called.
 */
int
ndmpdSelect(NdmpdSession*	session,
			bool_t			block,
			u_long			classMask)
{
	fd_set				rfds;
	fd_set				wfds;
	fd_set				efds;
	int					n;
	NdmpdFileHandler*	handler;
	
	if (session->fileHandlerList == 0)
		return(0);
	
	/* Create the fd_sets for select. */
	FD_ZERO(&rfds);
	FD_ZERO(&wfds);
	FD_ZERO(&efds);
	
	for (handler = session->fileHandlerList;
		 handler != 0;
		 handler = handler->next)
	{
		if ((handler->class & classMask) == 0)
			continue;
		
		if (handler->mode & 1)
			FD_SET(handler->fd, &rfds);

		if (handler->mode & 2)
			FD_SET(handler->fd, &wfds);

		if (handler->mode & 4)
			FD_SET(handler->fd, &efds);
	}

	if (block == TRUE)
	{
		n = select(FD_SETSIZE, &rfds, &wfds, &efds, 0);
	}
	else
	{
		struct timeval		timeout;
		timeout.tv_sec  = 0;
		timeout.tv_usec = 0;
		n = select(FD_SETSIZE, &rfds, &wfds, &efds, &timeout);
	}

	if (n < 0)
	{
		if (errno == EINTR)
			return(0);
		
		Error(LOG_ERR,
			  "ndmpdSelect: select error: %s.\n",
			  strerror(errno));
		return(-1);
	}

	if (n == 0)
		return(0);

	for (handler = session->fileHandlerList;
		 handler != 0;
		 handler = handler->next)
	{
		u_long	mode = 0;
		
		if ((handler->class & classMask) == 0)
			continue;
		
		if (handler->mode & 1)
		{
			if (FD_ISSET(handler->fd, &rfds))
				mode |= 1;
		}
		
		if (handler->mode & 2)
		{
			if (FD_ISSET(handler->fd, &wfds))
				mode |= 2;
		}
		
		if (handler->mode & 4)
		{
			if (FD_ISSET(handler->fd, &efds))
				mode |= 4;
		}
		
		if (mode)
			(*handler->func)(handler->cookie, handler->fd, mode);
	}

	return(1);
}


/*
 * ndmpdSaveEnv
 *   Saves a copy of the environment variable list from the data_start_backup
 *   request or data_start_recover request.
 *
 * Parameters:
 *   session (input) - session pointer.
 *   env     (input) - environment variable list to be saved.
 *   envlen  (input) - length of variable array.
 *
 * Returns:
 *   error code.
 */
ndmp_error
ndmpdSaveEnv(NdmpdSession*	session,
			 ndmp_pval		*env,
			 u_long			envlen)
{
	u_long	i;
	char*	namebuf;
	char*	valbuf;
	
	session->data.envLen = 0;

	if (envlen == 0)
		return(NDMP_NO_ERR);
	
	session->data.env = (ndmp_pval*)malloc(sizeof(ndmp_pval)*envlen);
	if (session->data.env == 0)
		return(NDMP_NO_MEM_ERR);
	
	for (i = 0; i < envlen; i++)
	{
		namebuf = (char*)malloc(strlen(env[i].name)+1);
		if (namebuf == 0)
		{
			Error(LOG_ERR, "ndmpdSaveEnv: malloc error: %s.\n",
				  strerror(errno));
			return(NDMP_NO_MEM_ERR);
		}
		
		valbuf  = (char*)malloc(strlen(env[i].value)+1);
		if (valbuf == 0)
		{
			Error(LOG_ERR, "ndmpdSaveEnv: malloc error: %s.\n",
				  strerror(errno));
			free(namebuf);
			return(NDMP_NO_MEM_ERR);
		}

		strcpy(namebuf, env[i].name);
		strcpy(valbuf,  env[i].value);
		
		session->data.env[i].name  = namebuf;
		session->data.env[i].value = valbuf;
		session->data.envLen++;
	}

	return(NDMP_NO_ERR);
}


/*
 * ndmpdFreeEnv
 *   Free the previously saved environment variable array.
 *
 * Parameters:
 *	 session - NDMP session pointer.
 *
 * Returns:
 *   void.
 */
void
ndmpdFreeEnv(NdmpdSession*	session)
{
	u_long	i;

	for (i = 0; i < session->data.envLen; i++)
	{
		free(session->data.env[i].name);
		free(session->data.env[i].value);
	}

	free((char *)session->data.env);
	session->data.env = 0;
	session->data.envLen = 0;
}


/*
 * ndmpdSaveNlist
 *   Save a copy of list of file names to be restored.
 *
 * Parameters:
 *   nlist    (input) - name list from data_start_recover request.
 *   nlistlen (input) - length of name list.
 * 
 * Returns:
 *   array of file name pointers.
 *
 * Notes:
 *   freeNlist should be called to free the returned list.
 *   A null pointer indicates the end of the list.
 */
ndmp_error
ndmpdSaveNlist(NdmpdSession*	session,
			   ndmp_name*		nlist,
			   u_long			nlistlen)
{
	u_long	i;
	char*	namebuf;
	char*	destbuf;
	char*	newbuf;
	char*	otherbuf;
		
	if (nlistlen == 0)
		return(NDMP_NO_ERR);
	
	session->data.nlistLen = 0;
	session->data.nlist = (ndmp_name*)malloc(sizeof(ndmp_name)*nlistlen);
	if (session->data.nlist == 0)
	{
		Error(LOG_ERR, "ndmpdSaveNlist: malloc error: %s.\n",
			  strerror(errno));
		return(NDMP_NO_MEM_ERR);
	}

	for (i = 0; i < nlistlen; i++)
	{
		namebuf = (char*)malloc(strlen(nlist[i].original_path)+1);
		if (namebuf == 0)
		{
			Error(LOG_ERR,
				  "ndmpdSaveNlist: malloc error: %s.\n",
				  strerror(errno));
			return(NDMP_NO_MEM_ERR);
		}
		
		destbuf = (char*)malloc(strlen(nlist[i].destination_dir)+1);
		if (destbuf == 0)
		{
			Error(LOG_ERR,
				  "ndmpdSaveNlist: malloc error: %s.\n",
				  strerror(errno));
			free(namebuf);
			return(NDMP_NO_MEM_ERR);
		}

		newbuf = (char*)malloc(strlen(nlist[i].new_name)+1);
		if (newbuf == 0)
		{
			Error(LOG_ERR,
				  "ndmpdSaveNlist: malloc error: %s.\n",
				  strerror(errno));
			free(namebuf);
			free(destbuf);
			return(NDMP_NO_MEM_ERR);
		}

		otherbuf = (char*)malloc(strlen(nlist[i].other_name)+1);
		if (otherbuf == 0)
		{
			Error(LOG_ERR,
				  "ndmpdSaveNlist: malloc error: %s.\n",
				  strerror(errno));
			free(namebuf);
			free(destbuf);
			free(newbuf);
			return(NDMP_NO_MEM_ERR);
		}

		strcpy(namebuf, nlist[i].original_path);
		strcpy(destbuf, nlist[i].destination_dir);
		strcpy(newbuf, nlist[i].new_name);
		strcpy(otherbuf, nlist[i].other_name);
		
		session->data.nlist[i].original_path    = namebuf;
		session->data.nlist[i].destination_dir  = destbuf;
		session->data.nlist[i].new_name         = newbuf;
		session->data.nlist[i].other_name       = otherbuf;
		session->data.nlist[i].fh_info          = nlist[i].fh_info;
		session->data.nlistLen++;
	}

	return(NDMP_NO_ERR);
}


/*
 * ndmpdFreeNlist
 *   Free a list created by ndmpdSaveNlist.
 *
 * Parameters:
 *   session (input) - session pointer.
 *
 * Returns:
 *   void
 */
void
ndmpdFreeNlist(NdmpdSession*	session)
{
	u_long	i;
	
	for (i = 0; i < session->data.nlistLen; i++)
	{
		free(session->data.nlist[i].original_path);
		free(session->data.nlist[i].destination_dir);
		free(session->data.nlist[i].new_name);
		free(session->data.nlist[i].other_name);
	}

	free((char *)session->data.nlist);
	session->data.nlist    = 0;
	session->data.nlistLen = 0;
}


void
ndmpdCreateMD5Challenge(NdmpdSession*	session,
						char			buf[64])
{
	memset(buf, 0, 64);
	memcpy((void*)buf, (void*)&session->id, 4);
}