Sync latest v2 into v3

CHANGELOG.md

@@ -1,5 +1,14 @@
 # Zowe Common C Changelog
 
+## `2.18.1`
+- Bugfix: IARV64 results must be checked for 0x7FFFF000 (#474)
+- Bugfix: SLH should not ABEND when MEMLIMIT is reached (additional NULL check)
+- Bugfix: support cross-memory server parameters longer than 128 characters 
+  (zowe/zss#684)
+
+## `2.18.0`
+- Minor `components.zss.logLevels._zss.httpserver=5` debug messages enhancement (#471)
+
 ## `2.17.0`
 - Fixed `xplatform.loadFileUTF8` when trying to open nonexistent file (#454)
 - Bugfix: fix an incorrect check in the recovery router code which might lead to

c/alloc.c

@@ -181,7 +181,12 @@ static char* __ptr64 getmain64(long long sizeInMegabytes, int *returnCode, int *
 
    if (returnCode) *returnCode = macroRetCode;
    if (reasonCode) *reasonCode = macroResCode;
-
+
+  // IARV64 returns 0x7FFFF000 when MEMLIMIT is reached
+  if (data == (void *)0x7FFFF000) {
+    data = NULL;
+  }
+
    return data;
 
 }
@@ -202,7 +207,12 @@ static char* __ptr64 getmain64ByToken(long long sizeInMegabytes, long long token
 
   if (returnCode) *returnCode = macroRetCode;
   if (reasonCode) *reasonCode = macroResCode;
-
+
+  // IARV64 returns 0x7FFFF000 when MEMLIMIT is reached
+  if (data == (void *)0x7FFFF000) {
+    data = NULL;
+  }
+
   return data;
 
 }

c/crossmemory.c

@@ -43,6 +43,8 @@
 #include "utils.h"
 #include "zvt.h"
 
+#define CMS_STATIC_ASSERT($expr) typedef char p[($expr) ? 1 : -1]
+
 #define CROSS_MEMORY_SERVER_MIN_NAME_LENGTH   4
 #define CROSS_MEMORY_SERVER_MAX_NAME_LENGTH   16
 
@@ -598,12 +600,32 @@ typedef struct CrossMemoryServerConfigServiceParm_tag {
   char eyecatcher[8];
 #define CMS_CONFIG_SERVICE_PARM_EYECATCHER "RSCMSCSY"
   char nameNullTerm[CMS_CONFIG_PARM_MAX_NAME_LENGTH + 1];
-  char padding[7];
-  CrossMemoryServerConfigParm result;
+  uint8_t version;
+#define CMS_CONFIG_SERVICE_PARM_VERSION_0 0
+#define CMS_CONFIG_SERVICE_PARM_VERSION_2 2
+#define CMS_CONFIG_SERVICE_PARM_SIZE_V0   227
+#define CMS_CONFIG_SERVICE_PARM_SIZE_V2   227
+#define CMS_CONFIG_SERVICE_PARM_VERSION   CMS_CONFIG_SERVICE_PARM_VERSION_2
+  char padding[6];
+  union {
+    CrossMemoryServerConfigParm result;
+    struct { // only for versions >= 2
+      int32_t nameLength;
+      int32_t valueBufferLength;
+      PAD_LONG(0, const char *name);
+      PAD_LONG(1, void *valueBuffer);
+      CrossMemoryServerConfigParmExt result;
+    } ext;
+  };
 } CrossMemoryServerConfigServiceParm;
 
 ZOWE_PRAGMA_PACK_RESET
 
+CMS_STATIC_ASSERT(CMS_CONFIG_SERVICE_PARM_SIZE_V0 ==
+                  sizeof(CrossMemoryServerConfigServiceParm));
+CMS_STATIC_ASSERT(CMS_CONFIG_SERVICE_PARM_SIZE_V2 ==
+                  sizeof(CrossMemoryServerConfigServiceParm));
+
 static void initLogMessagePrefix(LogMessagePrefix *prefix) {
   LogTimestamp currentTime;
   getCurrentLogTimestamp(&currentTime);
@@ -984,7 +1006,7 @@ int cmsAddConfigParm(CrossMemoryServer *server,
   ShortLivedHeap *slh = server->slh;
 
   size_t keyLength = strlen(name);
-  if (keyLength > CMS_CONFIG_PARM_MAX_NAME_LENGTH) {
+  if (keyLength > CMS_CONFIG_PARM_EXT_MAX_NAME_LENGTH) {
     return RC_CMS_CONFIG_PARM_NAME_TOO_LONG;
   }
 
@@ -995,28 +1017,33 @@ int cmsAddConfigParm(CrossMemoryServer *server,
 
   strcpy(keyNullTerm, name);
 
-  CrossMemoryServerConfigParm *parm =
-      (CrossMemoryServerConfigParm *)SLHAlloc(
+  CrossMemoryServerConfigParmExt *parm =
+      (CrossMemoryServerConfigParmExt *)SLHAlloc(
           slh,
-          sizeof(CrossMemoryServerConfigParm)
+          sizeof(CrossMemoryServerConfigParmExt)
       );
   if (parm == NULL) {
     return RC_CMS_SLH_ALLOC_FAILED;
   }
 
-  memcpy(parm->eyecatcher, CMS_PARM_EYECATCHER, sizeof(parm->eyecatcher));
+  memcpy(parm->eyecatcher, CMS_CONFIG_PARM_EXT_EYECATCHER,
+         sizeof(parm->eyecatcher));
   parm->type = type;
 
   switch (type) {
   case CMS_CONFIG_PARM_TYPE_CHAR:
   {
     const char *charValueNullTerm = value;
     size_t valueLength = strlen(charValueNullTerm);
-    if (valueLength > sizeof(parm->charValueNullTerm) - 1) {
+    if (valueLength > CMS_CONFIG_PARM_EXT_MAX_VALUE_SIZE) {
       return RC_CMS_CHAR_PARM_TOO_LONG;
     }
     parm->valueLength = valueLength;
-    strcpy(parm->charValueNullTerm, charValueNullTerm);
+    parm->value = SLHAlloc(slh, valueLength + 1);
+    if (parm->value == NULL) {
+      return RC_CMS_SLH_ALLOC_FAILED;
+    }
+    strcpy(parm->value, charValueNullTerm);
   }
   break;
   default:
@@ -1784,6 +1811,9 @@ static int handleConfigService(CrossMemoryServer *server,
     return RC_CMS_STDSVC_PARM_NULL;
   }
 
+  // Copying different versions using the same size is fine because both v0 and
+  // v2 have the same size, but, if this changes in the future, more complicated
+  // logic would need to be implemented.
   CrossMemoryServerConfigServiceParm localParm;
   cmCopyFromSecondaryWithCallerKey(&localParm, callerParm,
                                    sizeof(CrossMemoryServerConfigServiceParm));
@@ -1793,16 +1823,58 @@ static int handleConfigService(CrossMemoryServer *server,
     return RC_CMS_STDSVC_PARM_BAD_EYECATCHER;
   }
 
-  localParm.nameNullTerm[sizeof(localParm.nameNullTerm) - 1] = '\0';
-
-  CrossMemoryServerConfigParm *configParm =
-      htGet(server->configParms, localParm.nameNullTerm);
-  if (configParm == NULL) {
-    return RC_CMS_CONFIG_PARM_NOT_FOUND;
+  if (localParm.version != CMS_CONFIG_SERVICE_PARM_VERSION_0 &&
+      localParm.version != CMS_CONFIG_SERVICE_PARM_VERSION_2) {
+    return RC_CMS_STDSVC_PARM_BAD_VERSION;
   }
 
-  cmCopyToSecondaryWithCallerKey(&callerParm->result, configParm,
-                                 sizeof(callerParm->result));
+  if (localParm.version == CMS_CONFIG_SERVICE_PARM_VERSION_0) {
+    localParm.nameNullTerm[sizeof(localParm.nameNullTerm) - 1] = '\0';
+    CrossMemoryServerConfigParmExt *configParm = htGet(server->configParms,
+                                                       localParm.nameNullTerm);
+    if (configParm == NULL) {
+      return RC_CMS_CONFIG_PARM_NOT_FOUND;
+    }
+    size_t valueCopyLength = configParm->type == CMS_CONFIG_PARM_TYPE_CHAR ?
+        configParm->valueLength + 1 : configParm->valueLength;
+    if (valueCopyLength > sizeof(localParm.result.charValueNullTerm)) {
+      return RC_CMS_CONFIG_VALUE_BUF_TOO_SMALL;
+    }
+    localParm.result = (CrossMemoryServerConfigParm) {
+        .eyecatcher = CMS_PARM_EYECATCHER,
+        .valueLength = configParm->valueLength,
+        .type = configParm->type,
+    };
+    memcpy(localParm.result.charValueNullTerm, configParm->value,
+           valueCopyLength);
+    cmCopyToSecondaryWithCallerKey(callerParm, &localParm,
+                                   CMS_CONFIG_SERVICE_PARM_SIZE_V0);
+  } else {
+    char nameLocalBuffer[CMS_CONFIG_PARM_EXT_MAX_NAME_LENGTH + 1];
+    if (localParm.ext.nameLength > sizeof(nameLocalBuffer) - 1) {
+      return RC_CMS_CONFIG_PARM_NAME_TOO_LONG;
+    }
+    cmCopyFromSecondaryWithCallerKey(nameLocalBuffer, localParm.ext.name,
+                                     localParm.ext.nameLength);
+    nameLocalBuffer[localParm.ext.nameLength] = '\0';
+    CrossMemoryServerConfigParmExt *configParm = htGet(server->configParms,
+                                                       nameLocalBuffer);
+    if (configParm == NULL) {
+      return RC_CMS_CONFIG_PARM_NOT_FOUND;
+    }
+    size_t valueCopyLength = configParm->type == CMS_CONFIG_PARM_TYPE_CHAR ?
+        configParm->valueLength + 1 : configParm->valueLength;
+    localParm.ext.result = *configParm;
+    localParm.ext.result.value = localParm.ext.valueBuffer;
+    cmCopyToSecondaryWithCallerKey(callerParm, &localParm,
+                                   CMS_CONFIG_SERVICE_PARM_SIZE_V2);
+    if (valueCopyLength > localParm.ext.valueBufferLength) {
+      return RC_CMS_CONFIG_VALUE_BUF_TOO_SMALL;
+    }
+    cmCopyToSecondaryWithCallerKey(localParm.ext.valueBuffer,
+                                   configParm->value,
+                                   valueCopyLength);
+  }
 
   return RC_CMS_OK;
 }
@@ -5335,6 +5407,7 @@ int cmsGetConfigParm(const CrossMemoryServerName *serverName, const char *name,
   memcpy(parmList.eyecatcher, CMS_CONFIG_SERVICE_PARM_EYECATCHER,
          sizeof(parmList.eyecatcher));
   memcpy(parmList.nameNullTerm, name, nameLength);
+  parmList.version = CMS_CONFIG_SERVICE_PARM_VERSION_0;
 
   int serviceRC = cmsCallService(
       serverName,
@@ -5364,6 +5437,7 @@ int cmsGetConfigParmUnchecked(const CrossMemoryServerName *serverName,
   memcpy(parmList.eyecatcher, CMS_CONFIG_SERVICE_PARM_EYECATCHER,
          sizeof(parmList.eyecatcher));
   memcpy(parmList.nameNullTerm, name, nameLength);
+  parmList.version = CMS_CONFIG_SERVICE_PARM_VERSION_0;
 
   CrossMemoryServerGlobalArea *cmsGA = NULL;
   int getGlobalAreaRC = cmsGetGlobalArea(serverName, &cmsGA);
@@ -5387,6 +5461,91 @@ int cmsGetConfigParmUnchecked(const CrossMemoryServerName *serverName,
   return RC_CMS_OK;
 }
 
+int cmsGetConfigParmExt(const CrossMemoryServerName *serverName,
+                        const char *name,
+                        void *valueBuffer,
+                        int valueBufferSize,
+                        CrossMemoryServerConfigParmExt *parm,
+                        int *rsn) {
+
+  size_t nameLength = strlen(name);
+  if (nameLength > CMS_CONFIG_PARM_EXT_MAX_NAME_LENGTH) {
+    return RC_CMS_CONFIG_PARM_NAME_TOO_LONG;
+  }
+
+  CrossMemoryServerConfigServiceParm parmList = {
+      .eyecatcher = CMS_CONFIG_SERVICE_PARM_EYECATCHER,
+      .version = CMS_CONFIG_SERVICE_PARM_VERSION,
+      .ext.nameLength = nameLength,
+      .ext.name = name,
+      .ext.valueBufferLength = valueBufferSize,
+      .ext.valueBuffer = valueBuffer,
+  };
+
+  int serviceRC = cmsCallService(
+      serverName,
+      CROSS_MEMORY_SERVER_CONFIG_SERVICE_ID,
+      &parmList,
+      rsn
+  );
+  if (serviceRC != RC_CMS_OK) {
+    if (serviceRC == RC_CMS_CONFIG_VALUE_BUF_TOO_SMALL) {
+      *parm = parmList.ext.result;
+    }
+    return serviceRC;
+  }
+
+  *parm = parmList.ext.result;
+
+  return RC_CMS_OK;
+}
+
+int cmsGetConfigParmExtUnchecked(const CrossMemoryServerName *serverName,
+                                 const char *name,
+                                 void *valueBuffer,
+                                 int valueBufferSize,
+                                 CrossMemoryServerConfigParmExt *parm,
+                                 int *rsn) {
+
+  size_t nameLength = strlen(name);
+  if (nameLength > CMS_CONFIG_PARM_EXT_MAX_NAME_LENGTH) {
+    return RC_CMS_CONFIG_PARM_NAME_TOO_LONG;
+  }
+
+  CrossMemoryServerConfigServiceParm parmList = {
+      .eyecatcher = CMS_CONFIG_SERVICE_PARM_EYECATCHER,
+      .version = CMS_CONFIG_SERVICE_PARM_VERSION,
+      .ext.nameLength = nameLength,
+      .ext.name = name,
+      .ext.valueBufferLength = valueBufferSize,
+      .ext.valueBuffer = valueBuffer,
+  };
+
+  CrossMemoryServerGlobalArea *cmsGA = NULL;
+  int getGlobalAreaRC = cmsGetGlobalArea(serverName, &cmsGA);
+  if (getGlobalAreaRC != RC_CMS_OK) {
+    return getGlobalAreaRC;
+  }
+
+  int serviceRC = cmsCallService3(
+      cmsGA,
+      CROSS_MEMORY_SERVER_CONFIG_SERVICE_ID,
+      &parmList,
+      CMS_CALL_FLAG_NO_SAF_CHECK,
+      rsn
+  );
+  if (serviceRC != RC_CMS_OK) {
+    if (serviceRC == RC_CMS_CONFIG_VALUE_BUF_TOO_SMALL) {
+      *parm = parmList.ext.result;
+    }
+    return serviceRC;
+  }
+
+  *parm = parmList.ext.result;
+
+  return RC_CMS_OK;
+}
+
 int cmsGetPCLogLevel(const CrossMemoryServerName *serverName) {
 
   int logLevel = ZOWE_LOG_NA;

c/httpserver.c

@@ -2846,9 +2846,9 @@ int extractBasicAuth(HttpRequest *request, HttpHeader *authHeader){
     char *authString = NULL;
     AUTH_TRACE("start authEnd loop\n");
     while ((authEnd < headerLength) && (ebcdicHeader[authEnd] > 0x041)){
-      zowelog(NULL, LOG_COMP_HTTPSERVER, ZOWE_LOG_DEBUG3, "authEnd=%d\n",authEnd);
       authEnd++;
     }
+    zowelog(NULL, LOG_COMP_HTTPSERVER, ZOWE_LOG_DEBUG3, "authEnd=%d\n",authEnd);
     authLen = authEnd-authStart;
     encodedAuthString = SLHAlloc(slh,authLen+1);
     authString = SLHAlloc(slh,authLen+1);
@@ -2913,8 +2913,8 @@ int extractBearerToken(HttpRequest *request, HttpHeader *authHeader) {
   AUTH_TRACE("start tokenEnd loop\n");
   while ((tokenEnd < headerLength) && (ebcdicHeader[tokenEnd] > 0x041)){
     tokenEnd++;
-    zowelog(NULL, LOG_COMP_HTTPSERVER, ZOWE_LOG_DEBUG3, "tokenEnd=%d\n", tokenEnd);
   }
+  zowelog(NULL, LOG_COMP_HTTPSERVER, ZOWE_LOG_DEBUG3, "tokenEnd=%d\n", tokenEnd);
   const int tokenLen = tokenEnd - tokenStart;
   AUTH_TRACE("bearer token length = %d\n", tokenLen);
 

c/utils.c

@@ -1502,6 +1502,7 @@ char *SLHAlloc(ShortLivedHeap *slh, int size){
                       safeMalloc31(size+4,"SLH Oversize Extend"));
     if (bigBlock == NULL){
       reportSLHFailure(slh,size);
+      return NULL;
     }
     int *sizePtr = (int*)bigBlock;
     *sizePtr = size;
@@ -1528,6 +1529,7 @@ char *SLHAlloc(ShortLivedHeap *slh, int size){
                   safeMalloc31(slh->blockSize+4,"SLH Extend") );
     if (data == NULL){
       reportSLHFailure(slh,size);
+      return NULL;
     }
     int *sizePtr = (int*)data;
     *sizePtr = slh->blockSize;