Changeset 12910 for fact/Evidence/Evidence.cc

Timestamp:

02/20/12 22:04:50 (13 years ago)

Author:

ogrimm

Message:

EvidenceServer::ToString() can handle all DIM formats as long as padding is disabled

File:

• fact/Evidence/Evidence.cc (modified) (2 diffs)

fact/Evidence/Evidence.cc

@@ -103 +103 @@
   This = this;
 
+  dis_disable_padding();
+  dic_disable_padding();
+  
   // Initialise mutex
   int Ret;
@@ -407 +410 @@
 
 // Translates DIM data safely to string (assures no invalid memory accesses are made)
-string EvidenceServer::ToString(char *Format, void *Data, int Size) {
+// Structure evaluation requires that no padding is used
+string EvidenceServer::ToString(char *Format, const void *Data, int Size) {
 
   ostringstream Text;
-  
-  // 'Message' service format handled here
-  if (strcmp(Format, "I:1;C") == 0 && Size >= (int) sizeof(struct Message)) {
-        struct Message *Msg = (struct Message *) Data;
-        // Safely extract string and limit to length of C string (padding might make it longer)
-        string MsgText(Msg->Text, Size-sizeof(struct Message));
-        Text << Msg->Severity << " " << MsgText.erase(strlen(MsgText.c_str()));
-
-        return Text.str();
-  }
-
-  // String if format "C" and terminated with \0
-  if (strcmp(Format, "C") == 0 && Size > 0 && *((char *) Data+Size-1)=='\0') {
-        return string((char *) Data);
-  }
-  
-  // Check if format is made of identical component types
-  vector<string> Components = Tokenize(Format, ";");
-  
-  for (unsigned int i=0; i<Components.size(); i++) {
-        if (Components[i].empty()) return string();
-
-        // Print hex representation if format complex
-        if (Components[i][0] != Components[0][0]) {
-          for (int i=0; i<Size; i++) {
-                Text << setw(2) << hex << *((char *) Data + i) << " ";
-          } 
-          return Text.str();
-        }
-  }
-  
-  // Number array
-  int ElementSize;
-
-  switch (toupper(*Format)) {
-    case 'B':
-        case 'V':
-    case 'C': ElementSize = sizeof(char);               break;
-    case 'I':
-    case 'L': ElementSize = sizeof(int);                break;
-    case 'S': ElementSize = sizeof(short);              break;
-    case 'F': ElementSize = sizeof(float);              break;
-    case 'D': ElementSize = sizeof(double);             break;
-    case 'X': ElementSize = sizeof(long long);  break;
-    default: return string();
-  }
-
-  for (int i=0; i<Size/ElementSize; i++) {
-        // Space between entries
-    if (i != 0) Text << " ";
-
-        // Translate data
-        switch (toupper(*Format)) {
+  vector<string> Components;
+  int ElementSize, N, Byte = 0;
+
+  // Find component types
+  Components = Tokenize(Format, ";");
+  
+  for (unsigned int n=0; n<Components.size(); n++) {
+    // If empty, format error
+        if (Components[n].empty()) return string();
+
+        // Determine maximum number of elements 
+        if (Components[n].size() > 2) N = atoi(Components[n].c_str()+2); 
+        else N = numeric_limits<int>::max();
+
+        // Determine length in bytes of elements
+        switch (toupper(Components[n][0])) {
           case 'B':
           case 'V':
-      case 'C': Text << *((char *) Data + i);           break;
-      case 'I':
-      case 'L': Text << *((int *) Data + i);            break;
-      case 'S': Text << *((short *) Data + i);          break;
-      case 'F': Text << *((float *) Data + i);          break;
-      case 'D': Text << *((double *) Data + i);         break;
-      case 'X': Text << *((long long *) Data + i);      break;
+          case 'C': ElementSize = sizeof(char);                 break;
+          case 'I':
+          case 'L': ElementSize = sizeof(int);                  break;
+          case 'S': ElementSize = sizeof(short);                break;
+          case 'F': ElementSize = sizeof(float);                break;
+          case 'D': ElementSize = sizeof(double);               break;
+          case 'X': ElementSize = sizeof(long long);    break;
+          default: return string();
         }
-  }
-  
+
+        // Covert elements
+        for (int i=0; i<N; i++) {       
+          // Check that not overrunning memory
+          if (Byte + ElementSize > Size) return Text.str();
+          
+          // Translate elements into text (handle string specially when format is 'C')
+          switch (toupper(Components[n][0])) {
+        case 'C': if (Components[n].size() == 1) {
+                                        string String((char *) Data, Size-Byte);
+                                        
+                                        // Remove trailing '\0'
+                                        if (!String.empty() && String[String.size()-1] == '\0') String.resize(String.size()-1);
+                                        
+                                        Text << String;
+                                        return Text.str();
+                                  }
+                                  Text << *((char *) Data);
+                                  break;
+                case 'B':
+                case 'V': Text << *((char *) Data);
+                                  break;
+        case 'I':
+        case 'L': Text << *((int *) Data);
+                                  break;
+        case 'S': Text << *((short *) Data);
+                                  break;
+        case 'F': Text << *((float *) Data);
+                                  break;
+        case 'D': Text << *((double *) Data);
+                                  break;
+        case 'X': Text << *((long long *) Data);
+                              break;
+          }
+
+          Byte += ElementSize;
+          Data = (void *) ((char *) Data + ElementSize);
+
+          // Space between entries
+          Text << " ";
+        }
+  }
   return Text.str();
 }