Return to get.c CVS log

Up to [ELWIX - Embedded LightWeight unIX -] / libaitpelco / src

bugfix and secure code

    1: /*************************************************************************
    2: * (C) 2010 AITNET ltd - Sofia/Bulgaria - <misho@aitbg.com>
    3: *  by Michael Pounov <misho@openbsd-bg.org>
    4: *
    5: * $Author: misho $
    6: * $Id: get.c,v 1.1.1.1.2.2 2010/03/23 01:25:43 misho Exp $
    7: *
    8: *************************************************************************/
    9: #include "global.h"
   10: 
   11: 
   12: /*
   13:  * pelco_GetVersion() Return Pelco protocol version
   14:  * @p = Packet structure
   15:  * return: 'd' - PelcoD, 'p' - PelcoP, 0 - unknown or bad packet
   16:  */
   17: inline u_char pelco_GetVersion(void * __restrict p)
   18: {
   19: 	u_char *ptr = (u_char *) p;
   20: 
   21: 	if (!p || !*ptr) {
   22: 		pelcoSetErr(EINVAL, "invalid argument!\n");
   23: 		return 0;
   24: 	}
   25: 
   26: 	switch (*ptr) {
   27: 		case VER_D_SYNC:
   28: 			return 'd';
   29: 		case VER_P_STX:
   30: 			if (VER_P_ETX == ptr[6])
   31: 				return 'p';
   32: 			pelcoSetErr(ENOEXEC, "broken Pelco P packet ...\n");
   33: 			break;
   34: 		default:
   35: 			pelcoSetErr(ENOEXEC, "unsupported Pelco protocol version!\n");
   36: 	}
   37: 
   38: 	return 0;
   39: }
   40: 
   41: /*
   42:  * pelco_GetCamNo() Get Camera number and check for valid packet
   43:  * @p = Packet structure
   44:  * return: 0xFF and pelco_GetErrno() == ENOEXEC - error, 
   45:  	any number is camera address
   46:  */
   47: inline u_char pelco_GetCamNo(void * __restrict p)
   48: {
   49: 	u_char ver;
   50: 	u_char *ptr = (u_char *) p;
   51: 
   52: 	if (!p || !*ptr) {
   53: 		pelcoSetErr(EINVAL, "invalid argument!\n");
   54: 		return 0;
   55: 	}
   56: 
   57: 	ver = pelco_GetVersion(p);
   58: 	switch (ver) {
   59: 		case 'd':
   60: 			if (crcPelco(ver, p) == ptr[6])
   61: 				return ptr[1];
   62: 
   63: 			pelcoSetErr(ENOEXEC, "broken Pelco D packet!!!\n");
   64: 			break;
   65: 		case 'p':
   66: 			if (crcPelco(ver, p) == ptr[7])
   67: 				return ptr[1] + 1;
   68: 
   69: 			pelcoSetErr(ENOEXEC, "broken Pelco P packet!!!\n");
   70: 			break;
   71: 	}
   72: 
   73: 	return 0xFF;
   74: }
   75: 
   76: /*
   77:  * pelco_GetCamCmdData() Get from Camera commands and datas with verify packet
   78:  * @p = Input Packet structure
   79:  * @cam = Output camera number
   80:  * @cmd[2] = Output Commands 1 & 2
   81:  * @data[2] = Output Data for commands 1 & 2
   82:  * return: 'd' - PelcoD, 'p' - PelcoP, 0 - unknown or bad packet
   83:  */
   84: inline u_char pelco_GetCamCmdData(void * __restrict p, u_char * __restrict cam, 
   85: 		u_char * __restrict cmd, u_char * __restrict data)
   86: {
   87: 	u_char ret;
   88: 	u_char *ptr = (u_char *) p;
   89: 
   90: 	if (!p || !*ptr) {
   91: 		pelcoSetErr(EINVAL, "invalid argument!\n");
   92: 		return 0;
   93: 	}
   94: 
   95: 	ret = pelco_GetVersion(p);
   96: 	switch (ret) {
   97: 		case 'd':
   98: 			if (crcPelco(ret, p) != ptr[6]) {
   99: 				pelcoSetErr(ENOEXEC, "broken Pelco D packet!!!\n");
  100: 				return 0;
  101: 			}
  102: 
  103: 			if (cam)
  104: 				*cam = ptr[1];
  105: 			break;
  106: 		case 'p':
  107: 			if (crcPelco(ret, p) != ptr[7]) {
  108: 				pelcoSetErr(ENOEXEC, "broken Pelco P packet!!!\n");
  109: 				return 0;
  110: 			}
  111: 
  112: 			if (cam)
  113: 				*cam = ptr[1] + 1;
  114: 			break;
  115: 	}
  116: 
  117: 	if (cmd)
  118: 		memcpy(cmd, ptr + 2, 2);
  119: 	if (data)
  120: 		memcpy(data, ptr + 4, 2);
  121: 	return ret;
  122: }
  123: 
  124: /*
  125:  * pelco_D_toCmd() Convert to Pelco D commands
  126:  * @cmd[2] = Input Commands 1 & 2
  127:  * @cmd1 = Output typecasted commands 1
  128:  * @cmd2 = Output typecasted commands 2
  129:  * return: 0xFF - error, !=0 return number arguments
  130:  */
  131: inline u_char pelco_D_toCmd(u_char * __restrict cmd, 
  132: 		struct bitD_Cmd1 * __restrict cmd1, struct bitD_Cmd2 * __restrict cmd2)
  133: {
  134: 	u_char ret = 0;
  135: 
  136: 	if (!cmd) {
  137: 		pelcoSetErr(EINVAL, "invalid argument!\n");
  138: 		return 0xFF;
  139: 	}
  140: 
  141: 	if (cmd1) {
  142: 		cmd1 = (struct bitD_Cmd1*) &cmd[0];
  143: 		ret++;
  144: 	}
  145: 	if (cmd2) {
  146: 		cmd2 = (struct bitD_Cmd2*) &cmd[1];
  147: 		ret++;
  148: 	}
  149: 
  150: 	return ret;
  151: }
  152: 
  153: /*
  154:  * pelco_P_toCmd() Convert to Pelco P commands
  155:  * @cmd[2] = Input Commands 1 & 2
  156:  * @cmd1 = Output typecasted commands 1
  157:  * @cmd2 = Output typecasted commands 2
  158:  * return: 0xFF - error, !=0 return number arguments
  159:  */
  160: inline u_char pelco_P_toCmd(u_char * __restrict cmd, 
  161: 		struct bitP_Cmd1 * __restrict cmd1, struct bitP_Cmd2 * __restrict cmd2)
  162: {
  163: 	u_char ret = 0;
  164: 
  165: 	if (!cmd) {
  166: 		pelcoSetErr(EINVAL, "invalid argument!\n");
  167: 		return 0xFF;
  168: 	}
  169: 
  170: 	if (cmd1) {
  171: 		cmd1 = (struct bitP_Cmd1*) &cmd[0];
  172: 		ret++;
  173: 	}
  174: 	if (cmd2) {
  175: 		cmd2 = (struct bitP_Cmd2*) &cmd[1];
  176: 		ret++;
  177: 	}
  178: 
  179: 	return ret;
  180: }