XMLAttributeParser.h

Go to the documentation of this file.

#pragma once
 
#include <cstring>
#include "basic/Str.h"
 
namespace tiny_dlna {
 
class XMLAttributeParser {
 public:
  static bool extractAttribute(const char* xml, const char* tagName,
                               const char* attrName, char* outBuf,
                               size_t bufSize) {
    if (!xml || !tagName || !attrName || !outBuf || bufSize == 0) return false;
    const char* p = strstr(xml, tagName);
    while (p) {
      const char* tagEnd = strchr(p, '>');
      if (!tagEnd) return false;
      const char* attrPos = strstr(p, attrName);
      if (attrPos && attrPos < tagEnd) {
        // delegate actual quoted-value extraction to helper
        return extractQuotedValue(attrPos, tagEnd, outBuf, bufSize);
      }
      p = strstr(p + 1, tagName);
    }
    return false;
  }
 
  static bool extractAttribute(const char* attrs, const char* attrName,
                                         char* outBuf, size_t bufSize) {
    if (!attrs || !attrName || !outBuf || bufSize == 0) return false;
    const char* attrPos = strstr(attrs, attrName);
    if (!attrPos) return false;
    // No explicit boundary for attributes-only strings
    return extractQuotedValue(attrPos, nullptr, outBuf, bufSize);
  }
 
  // Helper: given a pointer somewhere at/after the attribute name, find the
  // next double-quoted value and copy it to outBuf. If `boundary` is non-null
  // the quotes must be before or equal to boundary.
  static bool extractQuotedValue(const char* attrPos, const char* boundary,
                                  char* outBuf, size_t bufSize) {
    if (!attrPos || !outBuf || bufSize == 0) return false;
    memset(outBuf, 0, bufSize);
    const char* q = strchr(attrPos, '"');
    if (!q) return false;
    if (boundary && q > boundary) return false;
    q++;
    const char* qend = strchr(q, '"');
    if (!qend) return false;
    if (boundary && qend > boundary) return false;
    size_t vlen = (size_t)(qend - q);
    size_t copyLen = vlen < (bufSize - 1) ? vlen : (bufSize - 1);
    if (copyLen > 0) memcpy(outBuf, q, copyLen);
    outBuf[copyLen] = '\0';
    return copyLen > 0;
  }
 
  static bool extractAttributeToken(const char* xml, const char* tagName,
                                     const char* attrName, int n,
                                     char* outBuf, size_t bufSize) {
    if (!xml || !tagName || !attrName || n <= 0 || !outBuf || bufSize == 0) return false;
    char proto[256] = {0};
    bool ok = extractAttribute(xml, tagName, attrName, proto, sizeof(proto));
    if (!ok || proto[0] == '\0') return false;
    // proto format: token1:token2:token3:token4
    int col = 1;
    const char* tokenStart = proto;
    if (n > 1) {
      for (size_t i = 0; proto[i] != '\0'; ++i) {
        if (proto[i] == ':') {
          ++col;
          if (col == n) {
            tokenStart = proto + i + 1;
            break;
          }
        }
      }
    }
    if (!tokenStart || *tokenStart == '\0') return false;
    // copy token into outBuf until ':' or end
    size_t j = 0;
    for (; tokenStart[j] != '\0' && tokenStart[j] != ':' && j + 1 < bufSize; ++j) outBuf[j] = tokenStart[j];
    outBuf[j] = '\0';
    return outBuf[0] != '\0';
  }
};
 
} // namespace tiny_dlna