snmptask.c

这里包含了风河vxworks系统中的官方例程的C源代码

 ** the packet prior to the set.
 **
 */

void taskEntry_test
  (
  OIDC_T      lastmatch,
  int         compc,
  OIDC_T     *compl,
  SNMP_PKT_T *pktp,
  VB_T       *vbp
  )
{
  int taskid, errorStatus = 0;
  STRUCT_taskEntry * pCheckData;
  VB_T *pGroupVbp;

  taskid = *compl;

  /* Allocate memory for vb_priv structure and setup the free routine */

  vbp->vb_priv = snmpdMemoryAlloc (sizeof (STRUCT_taskEntry));

  if (vbp->vb_priv == NULL) {
	testproc_error(pktp, vbp, RESOURCE_UNAVAILABLE);
	return;
  }

  bzero ((void *)vbp->vb_priv, sizeof (STRUCT_taskEntry));
  pCheckData = (STRUCT_taskEntry *) vbp->vb_priv;
  vbp->vb_free_priv = (VBPRIVPROC_T *) snmpVbPrivFree;

  /*  Check if instance is ok  */

  if (compc != TASK_TBL_INDEX_LEN) {
	testproc_error (pktp, vbp, NO_SUCH_NAME);
	return;
  }

  /*  Check if such an entry exists in the table  */

  pCheckData->taskId = taskid;		/* A taskId of zero should also be copied */

  if ((taskid != 0) && (taskInfoGet(taskid, &sysTaskVars) != OK)) { 
	testproc_error(pktp, vbp, NO_SUCH_NAME);
	return;
  }

  if (taskid) {
  	taskInfoFill (&sysTaskVars);
	memcpy ((char *)pCheckData, (char *)&data, sizeof (STRUCT_taskEntry));
  }

  /* find all the varbinds that share the same getproc and instance and
   * group them together. */

  snmpdGroupByGetprocAndInstance(pktp, vbp, compc, compl);

  /* now check each varbind */

  for (pGroupVbp = vbp; pGroupVbp; pGroupVbp=pGroupVbp->vb_link) {

    /* Each value has to be checked */

  switch (pGroupVbp->vb_ml.ml_last_match) {

  case LEAF_taskName:
		if (taskid != 0) {
			errorStatus = NOT_WRITABLE;
			goto errorReturn;
		}
      		break;

  case LEAF_taskPriority:
		if ((VB_GET_INT32(pGroupVbp) < 0) | (VB_GET_INT32(pGroupVbp) > 255)) {
			errorStatus = WRONG_VALUE;
			goto errorReturn;
		}
      		break;

  case LEAF_taskStatus:
		if (taskid == 0) {
			errorStatus = GEN_ERR;
			goto errorReturn;
		}
      		switch (VB_GET_INT32(pGroupVbp)) {
      		case VAL_taskStatus_task_ready:
      		case VAL_taskStatus_task_suspended:
      		case VAL_taskStatus_task_delay:
      		case VAL_taskStatus_task_deleted:
        		break;
      		default:
        		errorStatus = WRONG_VALUE;
			goto errorReturn;
        		continue;
      		}
      		break;

  case LEAF_taskOptions:
	/* If a task is being created, any options can be changed, otherwise 
	   only the VX_UNBREAKABLE option can be changed */

		if ((taskid == 0) && (VB_GET_INT32(pGroupVbp) & (VX_UNBREAKABLE | VX_DEALLOC_STACK | VX_FP_TASK | VX_PRIVATE_ENV | VX_NO_STACK_FILL | VX_SUPERVISOR_MODE | VX_STDIO)) == 0) {
			errorStatus = GEN_ERR;
			goto errorReturn;
		}
		else  
			if (VB_GET_INT32(pGroupVbp) != VX_UNBREAKABLE) {
				errorStatus = WRONG_VALUE;
				goto errorReturn;
			}
      		break;

  case LEAF_taskMain:
		if (taskid != 0) {
			errorStatus = GEN_ERR;
			goto errorReturn;
		}
      		break;

  case LEAF_taskStackSize:
		if (taskid != 0) {
			errorStatus = GEN_ERR;
			goto errorReturn;
		}
      		break;

  default:
      		errorStatus = GEN_ERR;
		goto errorReturn;
      		return;
    }
  }

  for (; vbp; vbp = vbp->vb_link) 
  	testproc_good (pktp, vbp);
  return;

  errorReturn:
	testproc_error(pktp, vbp, errorStatus);

}


/**********************************************************************
 ** This is the set method routine that is invoked after all the
 ** values in the received packet have been validated for a set
 ** operation.
 **
 */

void taskEntry_set
  (
  OIDC_T      lastmatch,
  int         compc,
  OIDC_T     *compl,
  SNMP_PKT_T *pktp,
  VB_T       *vbp
  )
{
  int errorStatus = 0;
  STRUCT_taskEntry newVals;
  VB_T *pVbpSaved = vbp;

  STRUCT_taskEntry *pCheckData = vbp->vb_priv;     
  bzero ((char *) &newVals, sizeof (STRUCT_taskEntry));
  newVals.taskId = pCheckData->taskId;

  /* Obtain all the values because you would need all of them if
     a task is to be spawned
  */

  for (; vbp; vbp = vbp->vb_link) {
	switch (vbp->vb_ml.ml_last_match) {
	
	case LEAF_taskName:
			memcpy (newVals.taskName, EBufferStart(VB_GET_STRING(vbp)), EBufferUsed (VB_GET_STRING(vbp)));
			break;

	case LEAF_taskPriority:
			newVals.taskPriority = VB_GET_INT32(vbp);
			break;

	case LEAF_taskStatus:
			newVals.taskStatus = VB_GET_INT32(vbp);
			break;

	case LEAF_taskOptions:
			newVals.taskOptions = VB_GET_INT32(vbp);
			break;

	case LEAF_taskMain:
			memcpy (newVals.taskMain, EBufferStart (VB_GET_STRING(vbp)), EBufferUsed (VB_GET_STRING(vbp)));
			break;

	case LEAF_taskStackSize:
			newVals.taskStackSize = VB_GET_INT32(vbp);
			break;

	default:
			continue;
	}
  }

  /* If taskId = 0, then create a new task, but first check if the 
     task entrypoint is listed in the symbol table */

  if (newVals.taskId == 0) {
	if ((errorStatus = taskSet (&newVals)) == COMMIT_FAILED)
		goto errorReturn;

	else {
		for (vbp = pVbpSaved; vbp; vbp = vbp->vb_link) 
			setproc_good (pktp, vbp);
		return;
	}
  } 


  /* A new row entry is not required. The existing entries are
     being modified
  */

  else {
	for (vbp = pVbpSaved; vbp; vbp = vbp->vb_link) {

    		switch (vbp->vb_ml.ml_last_match) {

    		case LEAF_taskPriority:
			if (taskPrioritySet (newVals.taskId, newVals.taskPriority) == ERROR) {
				errorStatus = COMMIT_FAILED;
				goto errorReturn;
			}
			varSet |= TSK_PRIOR; 
      			break;

    		case LEAF_taskStatus:
			if ((newVals.taskStatus == VAL_taskStatus_task_suspended) && (taskSuspend (newVals.taskId) != ERROR)) {
				varSet |= TSK_STAT_SUS;
				break;
			}
			if ((newVals.taskStatus == VAL_taskStatus_task_ready) && taskResume(newVals.taskId) != ERROR) {
				varSet |= TSK_STAT_RDY;
				break;
			}
			if ((newVals.taskStatus == VAL_taskStatus_task_deleted) && taskDelete(newVals.taskId) != ERROR) { 
				varSet |= TSK_STAT_DEL;
				break;
			}
			errorStatus = COMMIT_FAILED;
			goto errorReturn;
      			break;

    		case LEAF_taskOptions:
			if ((errorStatus = optionsSet (&newVals)) == COMMIT_FAILED) {
				goto errorReturn;
			}
			varSet |= TSK_OPTN;
      			break;

    		default:
			errorStatus = COMMIT_FAILED;
			goto errorReturn;
      			return;
    		}
  	}

	for (vbp = pVbpSaved; vbp; vbp = vbp->vb_link)
		setproc_good (pktp, vbp);
	return;


	errorReturn:
		pVbpSaved->undoproc = (UNDOPROC_T *) taskEntryUndo;
		snmpVbPrivFree (pVbpSaved);
		setproc_error (pktp, pVbpSaved, errorStatus);
  }
}



/*******************************************************************
 ** This routine is called when a set fails. All the previous sets
 ** would have to be cancelled. If a set has resulted in an existing
 ** task's deletion, that task is not restarted in this routine.
 **
 */

void taskEntryUndo 
    (
    OIDC_T              lastmatch,
    int                 compc,
    OIDC_T *            compl,
    SNMP_PKT_T *        pktp,
    VB_T *              vbp
    )
{
  int errorStatus = 0;
  STRUCT_taskEntry * pCheckData = vbp->vb_priv;

	if (varSet & TSK_PRIOR) {
		if (taskPrioritySet (pCheckData->taskId, pCheckData->taskPriority) == ERROR)
			errorStatus = UNDO_FAILED;
	}  

	if ((varSet & TSK_STAT_RDY) && (taskSuspend (pCheckData->taskId) == ERROR))  {
		errorStatus = UNDO_FAILED;
	}
	if ((varSet & TSK_STAT_SUS) && (taskResume (pCheckData->taskId) == ERROR))  {
		errorStatus = UNDO_FAILED;
	}

	if ((varSet & TSK_OPTN) && (optionsSet (pCheckData))) {
		errorStatus = UNDO_FAILED;
	}

 	if (errorStatus) { 
       		undoproc_error (pktp, vbp, UNDO_FAILED);
       		return;
	}

    	else 
		goto goodReturn;

    goodReturn:
   	undoproc_good (pktp, vbp);
    	return;
}



/***********************************************************************
 ** This is invoked from the set method routine when a new task is
 ** to be spawned. A new table entry is created as a result of this
 **
 */

int taskSet
    (
    STRUCT_taskEntry * pData
    )
{
    int errorStatus = 0;
    SYM_TYPE stype;
    char * tEntryRoutine;
    char tstring[DISPLAY_STR_SZ];

    strcat (tstring, pData->taskMain);
    if (symFindByCName (sysSymTbl, tstring, &tEntryRoutine, &stype) == ERROR) {
	errorStatus = NO_SUCH_NAME;
	return errorStatus;
    }

    strcpy (tstring, pData->taskName);
    if (taskSpawn (tstring, pData->taskPriority, pData->taskOptions, pData->taskStackSize, (FUNCPTR) tEntryRoutine, 0,0,0,0,0,0,0,0,0,0) == ERROR) {
                errorStatus = COMMIT_FAILED;
		return errorStatus;
    }
    return errorStatus;
}
      


/**********************************************************************
 ** This is called when the options for an existing task has to be 
 ** changed. This is also called from the undo routine.
 */


int optionsSet
    (
    STRUCT_taskEntry * pData
    )
{
    int toptions;
    int errorStatus = 0;

    if (taskOptionsGet (pData->taskId, &toptions) == ERROR) {
	errorStatus = COMMIT_FAILED;
	return errorStatus;
    }
    if ((toptions & VX_UNBREAKABLE) == 0) {
	if (taskOptionsSet (pData->taskId, ~toptions, (toptions | VX_UNBREAKABLE)) == ERROR) {
		errorStatus = COMMIT_FAILED;
		return errorStatus;
        }
    }
    else {
	toptions &= ~VX_UNBREAKABLE;
		if (taskOptionsSet (pData->taskId, VX_UNBREAKABLE, toptions) == ERROR) {
			errorStatus = COMMIT_FAILED;
			return errorStatus;
                }
    }
    return errorStatus;
}