Open Ethernet Networking (OpEN) API Guide and Reference Manual  3.6.0.3
image_example.c
/*********************************************************************
*
* Copyright 2016-2018 Broadcom
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*
**********************************************************************
*
* @filename image_example.c
*
* @purpose Example application to demonstrate various code image configuration APIs
*
* @component OpEN
*
* @note
*
* @create 11/17/2015
*
* @end
*
**********************************************************************/
#include <stdlib.h>
#include <stdbool.h>
#include <unistd.h>
#include "rpcclt_openapi.h"
#include "openapi_common.h"
#include "proc_util.h"
#define OPENAPI_DEFAULT_IMAGE_DESCR_MAX 256 /* As defined in openapi_limits.h */
#define OPEN_BUFF_EX_SIZE (256+1)
char *exampleName;
/*****************************************************************/
uint32_t imageFileNameMaxLengthGet (openapiClientHandle_t *clientHandle)
{
uint32_t max;
(void) openapiImageFileNameMaxLengthGet(clientHandle, &max);
return max;
}
/*****************************************************************/
void imageLabelsGet (openapiClientHandle_t *clientHandle,
uint32_t nameMaxLen,
char *activeLabel,
char *backupLabel)
{
open_buffdesc aBuffdesc;
open_buffdesc bBuffdesc;
aBuffdesc.pstart = activeLabel;
aBuffdesc.size = nameMaxLen;
bBuffdesc.pstart = backupLabel;
bBuffdesc.size = nameMaxLen;
result = openapiImageLabelsGet(clientHandle, &aBuffdesc, &bBuffdesc);
if (result != OPEN_E_NONE)
{
printf("Bad return code trying to get code image labels. (result = %d)\n", result);
}
else
{
printf("imageLabelsGet: activeLabel=%s backupLabel=%s\n",
(char *)aBuffdesc.pstart, (char *)bBuffdesc.pstart);
}
}
/*****************************************************************/
void imageNamesGet (openapiClientHandle_t *clientHandle,
uint32_t unit,
uint32_t nameMaxLen,
char *activeImage,
char *backupImage,
char *activatedImage)
{
open_buffdesc aBuffdesc;
open_buffdesc bBuffdesc;
open_buffdesc cBuffdesc;
aBuffdesc.pstart = activeImage;
aBuffdesc.size = nameMaxLen;
bBuffdesc.pstart = backupImage;
bBuffdesc.size = nameMaxLen;
cBuffdesc.pstart = activatedImage;
cBuffdesc.size = nameMaxLen;
result = openapiImageNamesGet(clientHandle, unit, &aBuffdesc, &bBuffdesc, &cBuffdesc);
if (result != OPEN_E_NONE)
{
printf("Bad return code trying to get code image names. (result = %d)\n", result);
}
else
{
printf("imageNamesGet: activeImage=%s backupImage=%s activatedImage=%s\n",
(char *)aBuffdesc.pstart, (char *)bBuffdesc.pstart, (char *)cBuffdesc.pstart);
}
}
/*****************************************************************/
void imageDescrGet (openapiClientHandle_t *clientHandle,
uint32_t nameMaxLen,
char *imageLabel,
char *imageDescr)
{
open_buffdesc aBuffdesc;
open_buffdesc bBuffdesc;
char labelStr[nameMaxLen];
strcpy(labelStr, imageLabel);
aBuffdesc.pstart = labelStr;
aBuffdesc.size = strlen(labelStr)+1;
bBuffdesc.pstart = imageDescr;
bBuffdesc.size = OPENAPI_DEFAULT_IMAGE_DESCR_MAX;
result = openapiImageDescrGet(clientHandle, &aBuffdesc, &bBuffdesc);
if (result != OPEN_E_NONE)
{
printf("Bad return code trying to get code image description. (result = %d)\n", result);
}
else
{
printf("imageDescrGet: imageLabel=%s imageDescr=%s\n", imageLabel, (char *)bBuffdesc.pstart);
}
}
/*****************************************************************/
void imageDescrSet (openapiClientHandle_t *clientHandle,
uint32_t nameMaxLen,
char *imageLabel,
char *imageDescr)
{
open_buffdesc aBuffdesc;
open_buffdesc bBuffdesc;
char labelStr[nameMaxLen];
char descrStr[OPENAPI_DEFAULT_IMAGE_DESCR_MAX];
strcpy(labelStr, imageLabel);
aBuffdesc.pstart = labelStr;
aBuffdesc.size = strlen(labelStr)+1;
strcpy(descrStr, imageDescr);
bBuffdesc.pstart = descrStr;
bBuffdesc.size = strlen(descrStr)+1;
result = openapiImageDescrSet(clientHandle, &aBuffdesc, &bBuffdesc);
if (result != OPEN_E_NONE)
{
printf("imageDescrSet: Bad return code trying to set code image description. (result = %d)\n", result);
}
else
{
printf("imageDescrSet: imageLabel=%s imageDescr=%s\n", imageLabel, imageDescr);
}
}
/*****************************************************************/
void imageLabelIsValid (openapiClientHandle_t *clientHandle,
uint32_t nameMaxLen,
char *imageLabel,
bool *isValid)
{
open_buffdesc buffdesc;
char labelStr[nameMaxLen];
strcpy(labelStr, imageLabel);
buffdesc.pstart = labelStr;
buffdesc.size = strlen(labelStr)+1;
result = openapiImageLabelIsValid(clientHandle, &buffdesc, &flag);
if (result != OPEN_E_NONE)
{
printf("Bad return code trying to validate code image. (result = %d)\n", result);
}
else
{
printf("imageLabelIsValid: imageLabel=%s isValid=%s.\n", imageLabel, (flag==OPEN_TRUE)?"true":"false");
*isValid = (flag==OPEN_TRUE)?true:false;
}
}
/*****************************************************************/
void imageActivate(openapiClientHandle_t *clientHandle,
uint32_t unit,
uint32_t nameMaxLen,
char *imageLabel,
OPEN_BOOL_t activate)
{
open_buffdesc buffdesc;
char labelStr[nameMaxLen];
strcpy(labelStr, imageLabel);
buffdesc.pstart = labelStr;
buffdesc.size = strlen(labelStr)+1;
result = openapiImageActivate(clientHandle, unit, &buffdesc, activate);
if (result != OPEN_E_NONE)
{
printf("imageActivate: Bad return code trying to set active image. (result = %d)\n", result);
}
else
{
printf("imageActivate: imageLabel=%s unit=%d.\n", imageLabel, unit);
}
}
/*****************************************************************/
void imageDelete(openapiClientHandle_t *clientHandle,
uint32_t unit,
uint32_t nameMaxLen,
char *imageLabel)
{
open_buffdesc buffdesc;
char labelStr[nameMaxLen];
strcpy(labelStr, imageLabel);
buffdesc.pstart = labelStr;
buffdesc.size = strlen(labelStr)+1;
result = openapiImageDelete(clientHandle, unit, &buffdesc);
if (result != OPEN_E_NONE)
{
printf("imageDelete: Bad return code trying to delete image. (result = %d)\n", result);
}
else
{
printf("imageDelete: imageLabel=%s unit=%d.\n", imageLabel, unit);
}
}
/*****************************************************************/
void bootcodeUpdate(openapiClientHandle_t *clientHandle,
uint32_t unit)
{
result = openapiBootCodeUpdate(clientHandle, unit);
if (result != OPEN_E_NONE)
{
printf("bootcodeUpdate: Bad return code trying to update bootcode. (result = %d)\n", result);
}
else
{
printf("bootcodeUpdate: unit=%d.\n", unit);
}
}
/*****************************************************************/
void imageOpENAPIUpgradeTest(openapiClientHandle_t *clientHandle,
uint32_t nameMaxLen,
char *imagePath,
char *imageLabel)
{
open_buffdesc imageLocation;
open_buffdesc imageName;
open_buffdesc activeBuffdesc;
open_buffdesc backupBuffdesc;
char activeLabel[nameMaxLen];
char backupLabel[nameMaxLen];
printf("Testing imageOpENAPIUpgradeTest()\n");
memset(activeLabel, 0, sizeof(activeLabel));
memset(backupLabel, 0, sizeof(backupLabel));
activeBuffdesc.pstart = activeLabel;
activeBuffdesc.size = sizeof(activeLabel); /* openapiImageLabelsGet() */
backupBuffdesc.pstart = backupLabel;
backupBuffdesc.size = sizeof(backupLabel);
result = openapiImageLabelsGet(clientHandle, &activeBuffdesc, &backupBuffdesc);
if (result != OPEN_E_NONE)
{
printf("Bad return code trying to get code image labels. (result = %d)\n", result);
return;
}
imageLocation.pstart = imagePath;
imageLocation.size = strlen(imagePath) + 1;
if (0 == strcmp(imageLabel, "active"))
{
imageName.pstart = activeLabel;
imageName.size = strlen(activeLabel) + 1;
}
else
{
imageName.pstart = backupLabel;
imageName.size = strlen(backupLabel) + 1;
}
result = openapiImageUpgrade(clientHandle, &imageLocation, &imageName);
if (result != OPEN_E_NONE)
{
printf("imageUpgrade: Bad return code trying to upgrade image [%s]. (result = %d)\n", imagePath, result);
}
else
{
printf("imageUpgrade: Successfully upgraded with image [%s]\n", imagePath);
}
}
/*****************************************************************/
void imageOpENAPIBootCodeVersion(openapiClientHandle_t *clientHandle)
{
open_buffdesc buffdesc;
char buf[OPEN_UBOOT_VERSION_LENGTH];
memset(buf, 0, sizeof(buf));
buffdesc.pstart = buf;
buffdesc.size = sizeof(buf);
result = openapiBootCodeVersion(clientHandle, &buffdesc);
if (result == OPEN_E_NONE)
{
printf("Bootcode version = %s\n", buf);
}
else
{
printf("Bootcode Version retrieve error\n");
}
return;
}
/***************************************************************/
void printImageAppMenu()
{
printf("\nUsage: image_example <test#> <arg1> <arg2> ...\n\n");
printf("Test 1: get image labels: %s 1\n", exampleName);
printf("Test 2: get image names: %s 2\n", exampleName);
printf("Test 3: get image descriptions: %s 3\n", exampleName);
printf("Test 4: get image description: %s 4 image\n", exampleName);
printf("Test 5: set image description: %s 5 image description\n", exampleName);
printf("Test 6: delete backup image: %s 6 image\n", exampleName);
printf("Test 7: check that that argument (e.g., 'active') is a valid image label for this platform: %s 7 image\n", exampleName);
printf("Test 8: update boot code: %s 8\n", exampleName);
printf("Test 9: activate backup image and update boot code: %s 9\n", exampleName);
printf("Test 10: activate backup image but do not update boot code: %s 10\n", exampleName);
printf("Test 11: copy image to switch: %s 11 label path\n", exampleName);
printf("Test 12: run negative tests: %s 12\n", exampleName);
printf("Test 13: Boot Code Version: %s 13 \n", exampleName);
return;
}
/*****************************************************************/
void imageOpENAPISanity(openapiClientHandle_t *clientHandle,
uint32_t nameMaxLen)
{
char activeLabel[nameMaxLen];
char activeImage[nameMaxLen];
char activeDescr[OPENAPI_DEFAULT_IMAGE_DESCR_MAX];
char backupLabel[nameMaxLen];
char backupImage[nameMaxLen];
char activatedImage[nameMaxLen];
uint32_t unit = 1;
open_error_t result;
open_buffdesc aBuffdesc;
open_buffdesc bBuffdesc;
open_buffdesc cBuffdesc;
open_buffdesc buffdesc;
aBuffdesc.pstart = activeImage;
aBuffdesc.size = nameMaxLen;
bBuffdesc.pstart = backupImage;
bBuffdesc.size = nameMaxLen;
cBuffdesc.pstart = activatedImage;
cBuffdesc.size = nameMaxLen;
result = openapiImageNamesGet(NULL, unit, &aBuffdesc, &bBuffdesc, &cBuffdesc);
if (result != OPEN_E_PARAM)
{
fprintf(stderr, "%s:%d FAIL expect OPEN_E_PARAM got %d\n",
__FUNCTION__, __LINE__, result);
exit(1);
}
result = openapiImageNamesGet(clientHandle, unit, NULL, &bBuffdesc, &cBuffdesc);
if (result != OPEN_E_PARAM)
{
fprintf(stderr, "%s:%d FAIL expect OPEN_E_PARAM got %d\n",
__FUNCTION__, __LINE__, result);
exit(1);
}
result = openapiImageNamesGet(clientHandle, unit, &aBuffdesc, NULL, &cBuffdesc);
if (result != OPEN_E_PARAM)
{
fprintf(stderr, "%s:%d FAIL expect OPEN_E_PARAM got %d\n",
__FUNCTION__, __LINE__, result);
exit(1);
}
result = openapiImageNamesGet(clientHandle, unit, &aBuffdesc, &bBuffdesc, NULL);
if (result != OPEN_E_PARAM)
{
fprintf(stderr, "%s:%d FAIL expect OPEN_E_PARAM got %d\n",
__FUNCTION__, __LINE__, result);
exit(1);
}
aBuffdesc.pstart = NULL;
result = openapiImageNamesGet(clientHandle, unit, &aBuffdesc, &bBuffdesc, &cBuffdesc);
if (result != OPEN_E_PARAM)
{
fprintf(stderr, "%s:%d FAIL expect OPEN_E_PARAM got %d\n",
__FUNCTION__, __LINE__, result);
exit(1);
}
aBuffdesc.pstart = activeImage;
aBuffdesc.size = nameMaxLen + 1;
result = openapiImageNamesGet(clientHandle, unit, &aBuffdesc, &bBuffdesc, &cBuffdesc);
if (result != OPEN_E_PARAM)
{
fprintf(stderr, "%s:%d FAIL expect OPEN_E_PARAM got %d\n",
__FUNCTION__, __LINE__, result);
exit(1);
}
aBuffdesc.size = nameMaxLen;
bBuffdesc.pstart = NULL;
bBuffdesc.size = nameMaxLen;
result = openapiImageNamesGet(clientHandle, unit, &aBuffdesc, &bBuffdesc, &cBuffdesc);
if (result != OPEN_E_PARAM)
{
fprintf(stderr, "%s:%d FAIL expect OPEN_E_PARAM got %d\n",
__FUNCTION__, __LINE__, result);
exit(1);
}
bBuffdesc.pstart = backupImage;
bBuffdesc.size = nameMaxLen + 1;
result = openapiImageNamesGet(clientHandle, unit, &aBuffdesc, &bBuffdesc, &cBuffdesc);
if (result != OPEN_E_PARAM)
{
fprintf(stderr, "%s:%d FAIL expect OPEN_E_PARAM got %d\n",
__FUNCTION__, __LINE__, result);
exit(1);
}
bBuffdesc.size = nameMaxLen;
cBuffdesc.pstart = NULL;
cBuffdesc.size = nameMaxLen;
result = openapiImageNamesGet(clientHandle, unit, &aBuffdesc, &bBuffdesc, &cBuffdesc);
if (result != OPEN_E_PARAM)
{
fprintf(stderr, "%s:%d FAIL expect OPEN_E_PARAM got %d\n",
__FUNCTION__, __LINE__, result);
exit(1);
}
cBuffdesc.pstart = activatedImage;
cBuffdesc.size = nameMaxLen + 1;
result = openapiImageNamesGet(clientHandle, unit, &aBuffdesc, &bBuffdesc, &cBuffdesc);
if (result != OPEN_E_PARAM)
{
fprintf(stderr, "%s:%d FAIL expect OPEN_E_PARAM got %d\n",
__FUNCTION__, __LINE__, result);
exit(1);
}
aBuffdesc.pstart = NULL;
aBuffdesc.size = nameMaxLen;
bBuffdesc.pstart = backupLabel;
bBuffdesc.size = nameMaxLen;
result = openapiImageLabelsGet(NULL, &aBuffdesc, &bBuffdesc);
if (result != OPEN_E_PARAM)
{
fprintf(stderr, "%s:%d FAIL expect OPEN_E_PARAM got %d\n",
__FUNCTION__, __LINE__, result);
exit(1);
}
aBuffdesc.pstart = activeLabel;
aBuffdesc.size = nameMaxLen + 1;
bBuffdesc.pstart = backupLabel;
bBuffdesc.size = nameMaxLen;
result = openapiImageLabelsGet(clientHandle, &aBuffdesc, &bBuffdesc);
if (result != OPEN_E_PARAM)
{
fprintf(stderr, "%s:%d FAIL expect OPEN_E_PARAM got %d\n",
__FUNCTION__, __LINE__, result);
exit(1);
}
aBuffdesc.pstart = activeLabel;
aBuffdesc.size = nameMaxLen;
bBuffdesc.pstart = NULL;
bBuffdesc.size = nameMaxLen;
result = openapiImageLabelsGet(clientHandle, &aBuffdesc, &bBuffdesc);
if (result != OPEN_E_PARAM)
{
fprintf(stderr, "%s:%d FAIL expect OPEN_E_PARAM got %d\n",
__FUNCTION__, __LINE__, result);
exit(1);
}
aBuffdesc.pstart = activeLabel;
aBuffdesc.size = nameMaxLen;
bBuffdesc.pstart = backupLabel;
bBuffdesc.size = nameMaxLen + 1;
result = openapiImageLabelsGet(clientHandle, &aBuffdesc, &bBuffdesc);
if (result != OPEN_E_PARAM)
{
fprintf(stderr, "%s:%d FAIL expect OPEN_E_PARAM got %d\n",
__FUNCTION__, __LINE__, result);
exit(1);
}
result = openapiImageLabelIsValid(0, &buffdesc, &flag);
if (result != OPEN_E_PARAM)
{
fprintf(stderr, "%s:%d FAIL expect OPEN_E_PARAM got %d\n",
__FUNCTION__, __LINE__, result);
exit(1);
}
/*
result = openapiImageLabelIsValid(clientHandle, NULL, &flag);
if (result != OPEN_E_PARAM)
{
fprintf(stderr, "%s:%d FAIL expect OPEN_E_PARAM got %d\n",
__FUNCTION__, __LINE__, result);
exit(1);
}
result = openapiImageLabelIsValid(clientHandle, &buffdesc, NULL);
if (result != OPEN_E_PARAM)
{
fprintf(stderr, "%s:%d FAIL expect OPEN_E_PARAM got %d\n",
__FUNCTION__, __LINE__, result);
exit(1);
}
*/
buffdesc.pstart = NULL;
buffdesc.size = nameMaxLen;
result = openapiImageLabelIsValid(clientHandle, &buffdesc, &flag);
if (result != OPEN_E_PARAM)
{
fprintf(stderr, "%s:%d FAIL expect OPEN_E_PARAM got %d\n",
__FUNCTION__, __LINE__, result);
exit(1);
}
result = openapiImageLabelIsValid(clientHandle, &buffdesc, &flag);
if (result != OPEN_E_PARAM)
{
fprintf(stderr, "%s:%d FAIL expect OPEN_E_PARAM got %d\n",
__FUNCTION__, __LINE__, result);
exit(1);
}
buffdesc.pstart = activeLabel;
buffdesc.size = nameMaxLen + 1;
result = openapiImageLabelIsValid(clientHandle, &buffdesc, &flag);
if (result != OPEN_E_PARAM)
{
fprintf(stderr, "%s:%d FAIL expect OPEN_E_PARAM got %d\n",
__FUNCTION__, __LINE__, result);
exit(1);
}
strcpy(activeLabel, "active");
aBuffdesc.pstart = activeLabel;
aBuffdesc.size = strlen(activeLabel)+1;
bBuffdesc.pstart = activeDescr;
bBuffdesc.size = OPENAPI_DEFAULT_IMAGE_DESCR_MAX;
result = openapiImageDescrGet(NULL, &aBuffdesc, &bBuffdesc);
if (result != OPEN_E_PARAM)
{
fprintf(stderr, "%s:%d FAIL expect OPEN_E_PARAM got %d\n",
__FUNCTION__, __LINE__, result);
exit(1);
}
result = openapiImageDescrGet(clientHandle, NULL, &bBuffdesc);
if (result != OPEN_E_PARAM)
{
fprintf(stderr, "%s:%d FAIL expect OPEN_E_PARAM got %d\n",
__FUNCTION__, __LINE__, result);
exit(1);
}
result = openapiImageDescrGet(clientHandle, &aBuffdesc, NULL);
if (result != OPEN_E_PARAM)
{
fprintf(stderr, "%s:%d FAIL expect OPEN_E_PARAM got %d\n",
__FUNCTION__, __LINE__, result);
exit(1);
}
aBuffdesc.pstart = NULL;
aBuffdesc.size = strlen(activeLabel)+1;
bBuffdesc.pstart = activeDescr;
bBuffdesc.size = OPENAPI_DEFAULT_IMAGE_DESCR_MAX;
result = openapiImageDescrGet(clientHandle, &aBuffdesc, &bBuffdesc);
if (result != OPEN_E_PARAM)
{
fprintf(stderr, "%s:%d FAIL expect OPEN_E_PARAM got %d\n",
__FUNCTION__, __LINE__, result);
exit(1);
}
aBuffdesc.pstart = activeLabel;
aBuffdesc.size = nameMaxLen + 1;
bBuffdesc.pstart = activeDescr;
bBuffdesc.size = OPENAPI_DEFAULT_IMAGE_DESCR_MAX;
result = openapiImageDescrGet(clientHandle, &aBuffdesc, &bBuffdesc);
if (result != OPEN_E_PARAM)
{
fprintf(stderr, "%s:%d FAIL expect OPEN_E_PARAM got %d\n",
__FUNCTION__, __LINE__, result);
exit(1);
}
aBuffdesc.pstart = activeLabel;
aBuffdesc.size = strlen(activeLabel)+1;
bBuffdesc.pstart = NULL;
bBuffdesc.size = OPENAPI_DEFAULT_IMAGE_DESCR_MAX;
result = openapiImageDescrGet(clientHandle, &aBuffdesc, &bBuffdesc);
if (result != OPEN_E_PARAM)
{
fprintf(stderr, "%s:%d FAIL expect OPEN_E_PARAM got %d\n",
__FUNCTION__, __LINE__, result);
exit(1);
}
aBuffdesc.pstart = activeLabel;
aBuffdesc.size = strlen(activeLabel)+1;
bBuffdesc.pstart = activeDescr;
bBuffdesc.size = OPENAPI_DEFAULT_IMAGE_DESCR_MAX + 1;
result = openapiImageDescrGet(clientHandle, &aBuffdesc, &bBuffdesc);
if (result != OPEN_E_PARAM)
{
fprintf(stderr, "%s:%d FAIL expect OPEN_E_PARAM got %d\n",
__FUNCTION__, __LINE__, result);
exit(1);
}
aBuffdesc.pstart = activeLabel;
aBuffdesc.size = strlen(activeLabel)+1;
bBuffdesc.pstart = activeDescr;
bBuffdesc.size = OPENAPI_DEFAULT_IMAGE_DESCR_MAX;
result = openapiImageDescrSet(NULL, &aBuffdesc, &bBuffdesc);
if (result != OPEN_E_PARAM)
{
fprintf(stderr, "%s:%d FAIL expect OPEN_E_PARAM got %d\n",
__FUNCTION__, __LINE__, result);
exit(1);
}
aBuffdesc.pstart = activeLabel;
aBuffdesc.size = strlen(activeLabel)+1;
bBuffdesc.pstart = activeDescr;
bBuffdesc.size = OPENAPI_DEFAULT_IMAGE_DESCR_MAX;
result = openapiImageDescrSet(clientHandle, NULL, &bBuffdesc);
if (result != OPEN_E_PARAM)
{
fprintf(stderr, "%s:%d FAIL expect OPEN_E_PARAM got %d\n",
__FUNCTION__, __LINE__, result);
exit(1);
}
aBuffdesc.pstart = activeLabel;
aBuffdesc.size = strlen(activeLabel)+1;
bBuffdesc.pstart = activeDescr;
bBuffdesc.size = OPENAPI_DEFAULT_IMAGE_DESCR_MAX;
result = openapiImageDescrSet(clientHandle, &aBuffdesc, NULL);
if (result != OPEN_E_PARAM)
{
fprintf(stderr, "%s:%d FAIL expect OPEN_E_PARAM got %d\n",
__FUNCTION__, __LINE__, result);
exit(1);
}
aBuffdesc.pstart = NULL;
aBuffdesc.size = strlen(activeLabel)+1;
bBuffdesc.pstart = activeDescr;
bBuffdesc.size = OPENAPI_DEFAULT_IMAGE_DESCR_MAX;
result = openapiImageDescrSet(clientHandle, &aBuffdesc, &bBuffdesc);
if (result != OPEN_E_PARAM)
{
fprintf(stderr, "%s:%d FAIL expect OPEN_E_PARAM got %d\n",
__FUNCTION__, __LINE__, result);
exit(1);
}
aBuffdesc.pstart = activeLabel;
aBuffdesc.size = nameMaxLen + 1;
bBuffdesc.pstart = activeDescr;
bBuffdesc.size = OPENAPI_DEFAULT_IMAGE_DESCR_MAX;
result = openapiImageDescrSet(clientHandle, &aBuffdesc, &bBuffdesc);
if (result != OPEN_E_PARAM)
{
fprintf(stderr, "%s:%d FAIL expect OPEN_E_PARAM got %d\n",
__FUNCTION__, __LINE__, result);
exit(1);
}
aBuffdesc.pstart = activeLabel;
aBuffdesc.size = 0;
bBuffdesc.pstart = activeDescr;
bBuffdesc.size = OPENAPI_DEFAULT_IMAGE_DESCR_MAX;
result = openapiImageDescrSet(clientHandle, &aBuffdesc, &bBuffdesc);
if (result != OPEN_E_FAIL)
{
fprintf(stderr, "%s:%d FAIL expect OPEN_E_FAIL got %d\n",
__FUNCTION__, __LINE__, result);
exit(1);
}
aBuffdesc.pstart = activeLabel;
aBuffdesc.size = strlen(activeLabel)+1;
bBuffdesc.pstart = NULL;
bBuffdesc.size = OPENAPI_DEFAULT_IMAGE_DESCR_MAX;
result = openapiImageDescrSet(clientHandle, &aBuffdesc, &bBuffdesc);
if (result != OPEN_E_PARAM)
{
fprintf(stderr, "%s:%d FAIL expect OPEN_E_PARAM got %d\n",
__FUNCTION__, __LINE__, result);
exit(1);
}
aBuffdesc.pstart = activeLabel;
aBuffdesc.size = strlen(activeLabel)+1;
bBuffdesc.pstart = activeDescr;
bBuffdesc.size = OPENAPI_DEFAULT_IMAGE_DESCR_MAX + 1;
result = openapiImageDescrSet(clientHandle, &aBuffdesc, &bBuffdesc);
if (result != OPEN_E_PARAM)
{
fprintf(stderr, "%s:%d FAIL expect OPEN_E_PARAM got %d\n",
__FUNCTION__, __LINE__, result);
exit(1);
}
buffdesc.pstart = activeLabel;
buffdesc.size = strlen(activeLabel)+1;
result = openapiImageActivate(NULL, unit, &buffdesc, OPEN_TRUE);
if (result != OPEN_E_PARAM)
{
fprintf(stderr, "%s:%d FAIL expect OPEN_E_PARAM got %d\n",
__FUNCTION__, __LINE__, result);
exit(1);
}
buffdesc.pstart = NULL;
buffdesc.size = strlen(activeLabel)+1;
result = openapiImageActivate(NULL, unit, &buffdesc, OPEN_TRUE);
if (result != OPEN_E_PARAM)
{
fprintf(stderr, "%s:%d FAIL expect OPEN_E_PARAM got %d\n",
__FUNCTION__, __LINE__, result);
exit(1);
}
buffdesc.pstart = activeLabel;
buffdesc.size = strlen(activeLabel)+1;
result = openapiImageActivate(NULL, unit, &buffdesc, OPEN_TRUE);
if (result != OPEN_E_PARAM)
{
fprintf(stderr, "%s:%d FAIL expect OPEN_E_PARAM got %d\n",
__FUNCTION__, __LINE__, result);
exit(1);
}
result = openapiImageActivate(clientHandle, unit, NULL, OPEN_TRUE);
if (result != OPEN_E_PARAM)
{
fprintf(stderr, "%s:%d FAIL expect OPEN_E_PARAM got %d\n",
__FUNCTION__, __LINE__, result);
exit(1);
}
/* note, this is a bad parameter (17) but implementation returns OPEN_E_FAIL */
result = openapiImageActivate(clientHandle, unit, &buffdesc, 17);
if (result != OPEN_E_FAIL)
{
fprintf(stderr, "%s:%d FAIL expect OPEN_E_FAIL got %d\n",
__FUNCTION__, __LINE__, result);
exit(1);
}
result = openapiImageDelete(NULL, unit, &buffdesc);
if (result != OPEN_E_PARAM)
{
fprintf(stderr, "%s:%d FAIL expect OPEN_E_PARAM got %d\n",
__FUNCTION__, __LINE__, result);
exit(1);
}
/* Note, this is a bad param, but impl returns OPEN_E_FAIL */
result = openapiImageDelete(clientHandle, -1, &buffdesc);
if (result != OPEN_E_FAIL)
{
fprintf(stderr, "%s:%d FAIL expect OPEN_E_FAIL got %d\n",
__FUNCTION__, __LINE__, result);
exit(1);
}
result = openapiImageDelete(clientHandle, unit, NULL);
if (result != OPEN_E_PARAM)
{
fprintf(stderr, "%s:%d FAIL expect OPEN_E_PARAM got %d\n",
__FUNCTION__, __LINE__, result);
exit(1);
}
buffdesc.pstart = NULL;
buffdesc.size = OPENAPI_DEFAULT_IMAGE_DESCR_MAX;
result = openapiImageDelete(clientHandle, unit, &buffdesc);
if (result != OPEN_E_PARAM)
{
fprintf(stderr, "%s:%d FAIL expect OPEN_E_PARAM got %d\n",
__FUNCTION__, __LINE__, result);
exit(1);
}
buffdesc.pstart = activeLabel;
buffdesc.size = OPENAPI_DEFAULT_IMAGE_DESCR_MAX + 1;
result = openapiImageDelete(clientHandle, unit, &buffdesc);
if (result != OPEN_E_PARAM)
{
fprintf(stderr, "%s:%d FAIL expect OPEN_E_PARAM got %d\n",
__FUNCTION__, __LINE__, result);
exit(1);
}
fprintf(stderr, "All sanity tests were successful.");
return;
}
/***************************************************************/
int main(int argc, char **argv)
{
openapiClientHandle_t clientHandle;
open_buffdesc switch_os_revision;
char switch_os_revision_string[100];
open_error_t result;
uint32_t testNum;
uint32_t nameMaxLen;
int unit = 1;
bool isValid;
char activeDescr[OPENAPI_DEFAULT_IMAGE_DESCR_MAX];
char backupDescr[OPENAPI_DEFAULT_IMAGE_DESCR_MAX];
char *activeLabel = NULL;
char *activeImage = NULL;
char *backupLabel = NULL;
char *backupImage = NULL;
char *activatedImage = NULL;
exampleName = argv[0];
if (argc < 2)
{
printImageAppMenu();
exit(1);
}
testNum = atoi(argv[1]);
l7proc_crashlog_register();
/* Register with OpEN */
if ((result = openapiClientRegister("image_example", &clientHandle)) != OPEN_E_NONE)
{
printf("\nFailed to initialize RPC to OpEN. Exiting (result = %d)\n", result);
exit(2);
}
/* RPC call can fail until server starts. Keep trying */
while (openapiConnectivityCheck(&clientHandle) != OPEN_E_NONE)
{
sleep(1);
}
L7PROC_LOGF(L7PROC_LOG_SEVERITY_INFO, 0, "Starting Code Image API example application");
printf("\n");
switch_os_revision.pstart = switch_os_revision_string;
switch_os_revision.size = sizeof(switch_os_revision_string);
if (openapiNetworkOSVersionGet(&clientHandle, &switch_os_revision) == OPEN_E_NONE)
{
printf("Network OS version = %s\n", switch_os_revision_string);
}
else
{
printf("Network OS version retrieve error\n");
}
nameMaxLen = imageFileNameMaxLengthGet(&clientHandle);
activeLabel = (char*)malloc(nameMaxLen);
activeImage = (char*)malloc(nameMaxLen);
backupLabel = (char*)malloc(nameMaxLen);
backupImage = (char*)malloc(nameMaxLen);
activatedImage = (char*)malloc(nameMaxLen);
memset(activeLabel, 0, nameMaxLen);
memset(activeImage, 0, nameMaxLen);
memset(backupLabel, 0, nameMaxLen);
memset(backupImage, 0, nameMaxLen);
memset(activatedImage, 0, nameMaxLen);
printf("\n");
switch (testNum)
{
case 1:
if (argc != 2)
{
printImageAppMenu();
exit(1);
}
imageLabelsGet(&clientHandle, nameMaxLen, activeLabel, backupLabel);
break;
case 2:
if (argc != 2)
{
printImageAppMenu();
exit(1);
}
imageNamesGet(&clientHandle, unit, nameMaxLen, activeImage, backupImage, activatedImage);
break;
case 3:
if (argc != 2)
{
printImageAppMenu();
exit(1);
}
imageLabelsGet(&clientHandle, nameMaxLen, activeLabel, backupLabel);
imageDescrGet(&clientHandle, nameMaxLen, activeLabel, activeDescr);
imageDescrGet(&clientHandle, nameMaxLen, backupLabel, backupDescr);
break;
case 4:
if (argc != 3)
{
printImageAppMenu();
exit(1);
}
imageLabelsGet(&clientHandle, nameMaxLen, activeLabel, backupLabel);
if ((0 != strcmp(argv[2], activeLabel)) && (0 != strcmp(argv[2], backupLabel)))
{
printImageAppMenu();
exit(1);
}
imageDescrGet(&clientHandle, nameMaxLen, argv[2], activeDescr);
break;
case 5:
if (argc != 4)
{
printImageAppMenu();
exit(1);
}
imageLabelsGet(&clientHandle, nameMaxLen, activeLabel, backupLabel);
if ((0 != strcmp(argv[2], activeLabel)) && (0 != strcmp(argv[2], backupLabel)))
{
printImageAppMenu();
exit(1);
}
imageDescrSet(&clientHandle, nameMaxLen, argv[2], argv[3]);
break;
case 6:
if (argc != 3)
{
printImageAppMenu();
exit(1);
}
imageLabelsGet(&clientHandle, nameMaxLen, activeLabel, backupLabel);
if (strcmp(backupLabel, argv[2]) == 0)
{
imageDelete(&clientHandle, unit, nameMaxLen, argv[2]);
}
else
{
printf("Unable to delete a non-backup image '%s'. Try again with '%s'\n",
argv[2], backupLabel);
}
break;
case 7:
if (argc != 3)
{
printImageAppMenu();
exit(1);
}
imageLabelIsValid(&clientHandle, nameMaxLen, argv[2], &isValid);
break;
case 8:
if (argc != 2)
{
printImageAppMenu();
exit(1);
}
bootcodeUpdate(&clientHandle, unit);
break;
case 9:
if (argc != 2)
{
printImageAppMenu();
exit(1);
}
imageLabelsGet(&clientHandle, nameMaxLen, activeLabel, backupLabel);
imageActivate(&clientHandle, unit, nameMaxLen, backupLabel, OPEN_TRUE);
break;
case 10:
if (argc != 2)
{
printImageAppMenu();
exit(1);
}
imageLabelsGet(&clientHandle, nameMaxLen, activeLabel, backupLabel);
imageActivate(&clientHandle, unit, nameMaxLen, backupLabel, OPEN_FALSE);
break;
case 11:
if (argc != 4)
{
printImageAppMenu();
exit(1);
}
if ((0 != strcmp(argv[2], "active")) && (0 != strcmp(argv[2], "backup")))
{
printImageAppMenu();
exit(1);
}
imageOpENAPIUpgradeTest(&clientHandle, nameMaxLen, argv[3], argv[2]);
break;
case 12:
if (argc != 2)
{
printImageAppMenu();
exit(1);
}
imageOpENAPISanity(&clientHandle, nameMaxLen);
break;
case 13:
if (argc != 2)
{
printImageAppMenu();
exit(1);
}
imageOpENAPIBootCodeVersion(&clientHandle);
break;
default:
printImageAppMenu();
break;
}
/* Log goodbye message with OpEN */
L7PROC_LOGF(L7PROC_LOG_SEVERITY_INFO, 0, "Stopping Code Image API example application");
free(activeLabel);
free(activeImage);
free(backupLabel);
free(backupImage);
free(activatedImage);
(void) openapiClientTearDown(&clientHandle);
return 0;
}