sdp_data.cpp

00001 #include "mbed.h"
00002 #include "sdp_data.h"
00003 #include "Utils.h"
00004 
00005 char sdp_data::ret[12];
00006 
00007 unsigned sdp_data::asUnsigned() {
00008     switch (type) {
00009         case NULL_:
00010             return 0;
00011         case UNSIGNED:
00012         case SIGNED:
00013         case BOOL:
00014             return data;
00015         case UUID:
00016 #ifdef LONGUUID
00017             return uuid[6] + uuid[7]<<16;
00018 #else
00019             return data;
00020 #endif
00021         default:
00022             return 0;
00023     }
00024 }
00025 
00026 const char* sdp_data::asString(bool alt) {
00027     char sep = ',';
00028     switch (type) {
00029         case NULL_:
00030             return "NULL";
00031         case UNSIGNED:
00032             if (alt) sprintf(ret, "0x%0*X", size*2, data);
00033             else sprintf(ret, "%u", data);
00034             return ret;
00035         case SIGNED:
00036             sprintf(ret, "%d", data);
00037             return ret;
00038         case BOOL:
00039             return data ? "TRUE" : "FALSE";
00040         case STRING:
00041         case URL:
00042             return str;
00043         case ALTERNATIVE:
00044             sep = '|';
00045         case SEQUENCE: {
00046             if (longstr) delete[] longstr;
00047             int n = sprintf(ret, "SEQ %d { ", size) + 1;
00048             longstr = new char[n];
00049             strcpy(longstr, ret);
00050             for (int i = 0; i < sequence.size(); i++) {
00051                 const char *s = sequence[i]->asString(alt);
00052                 n = strlen(longstr) + strlen(s) + 2;
00053                 char *t = new char[n];
00054                 strcpy(t, longstr);
00055                 strcat(t, s);
00056                 t[n-2] = sep;
00057                 t[n-1]='\0';
00058                 //printf("[%s]+[%s]+%c=[%s]\n", longstr, s, sep, t);
00059                 delete[] longstr;
00060                 longstr = t;
00061             }
00062             longstr[n-2] = '}';
00063         }
00064         return longstr;
00065         case UUID:
00066 #ifdef LONGUUID
00067             switch (size) {
00068                 case 2:
00069                     sprintf(ret, "0x%04X", uuid[6]);
00070                     return ret;
00071                 case 4:
00072                     sprintf(ret, "0x%04X%04X", uuid[7],uuid[6]);
00073                     return ret;
00074                 case 16:
00075                     longstr = new char[35];
00076                     sprintf(longstr, "%04X%04X-%04X-%04X-%04X-%04X%04X%04X", uuid[7],uuid[6],uuid[5],uuid[4],uuid[3],uuid[2],uuid[1],uuid[0]);
00077                     return longstr;
00078             }
00079 #else
00080             switch (size) {
00081                 case 2:
00082                     sprintf(ret, "0x%04X", data & 0xffff);
00083                     return ret;
00084                 case 4:
00085                     sprintf(ret, "0x%08X", data);
00086                     return ret;
00087                 case 16:
00088                     longstr = new char[35];
00089                     sprintf(longstr, "%08X-%04X-%04X-%04X-%04X%04X%04X", data,base_uuid[5],base_uuid[4],base_uuid[3],base_uuid[2],base_uuid[1],base_uuid[0]);
00090                     return longstr;
00091             }
00092 #endif
00093     }
00094     return "Unsupported";
00095 }
00096 
00097 unsigned sdp_data::Size() {
00098     if (size==0 && type==SEQUENCE)
00099       return 2;
00100     if (size<3 || size==4 || size==8 || size==16)
00101         return size+1;//include descriptor
00102     if (size < 256) return size+2; //1 extra byte
00103     if (size < 65536) return size+3; //2 extra bytes
00104     return size+5; //4 extra bytes
00105 }
00106 
00107 unsigned sdp_data::sizedesc(unsigned char *buf) {
00108     int desc, extra=0;
00109     switch (size) {
00110         case 0:
00111         /* should be:
00112            if (type != NULL_) {
00113                 desc = 5;
00114                 extra = 1;
00115                 buf[1] = 0;
00116            }
00117         */
00118         case 1:
00119             desc = 0;
00120             break;
00121         case 2:
00122             desc = 1;
00123             break;
00124         case 4:
00125             desc = 2;
00126             break;
00127         case 8:
00128             desc = 3;
00129             break;
00130         case 16:
00131             desc = 4;
00132             break;
00133         default:
00134             if (size < 256) {
00135                 desc = 5;
00136                 extra = 1;
00137                 buf[1] = size;
00138             } else if (size < 65536) {
00139                 desc = 6;
00140                 extra = 2;
00141                 *(unsigned short*)&buf[1] = size;
00142             } else {
00143                 desc = 7;
00144                 extra = 4;
00145                 *(unsigned*)&buf[1] = size;
00146             }
00147     }
00148     buf[0] |= desc;
00149     return extra+1;
00150 }
00151 
00152 void sdp_data::revcpy(unsigned char*d, const unsigned char*s, int n) {
00153     for (int i = 0; i < n; i++)
00154         d[i] = s[n-i-1];
00155 }
00156 
00157 unsigned sdp_data::build(unsigned char *buf, unsigned max) {//max is ignored
00158     int p = 0;
00159     buf[p] = type<<3;
00160     switch (type) {
00161         case NULL_:
00162             p++;
00163             break;
00164         case UNSIGNED:
00165         case SIGNED:
00166         case BOOL:
00167             p += sizedesc(buf+p);
00168             revcpy(buf+p, (unsigned char*)&data, size);
00169             break;
00170         case UUID:
00171             p += sizedesc(buf+p);
00172 #ifdef LONGUUID
00173             switch (size) {
00174                 case 2:
00175                 case 4:
00176                     revcpy(buf+p, (unsigned char*)&uuid[6], size);
00177                     break;
00178                 case 16:
00179                     revcpy(buf+p, (unsigned char*)uuid, size);
00180                     break;
00181             }
00182 #else
00183             switch (size) {
00184                 case 2:
00185                 case 4:
00186                     revcpy(buf+p, (unsigned char*)&data, size);
00187                     break;
00188                 case 16:
00189                     revcpy(buf+p, (unsigned char*)&data, 4);
00190                     revcpy(buf+p+4, base_uuid, 12);
00191                     break;
00192             }
00193 #endif
00194             break;
00195         case STRING:
00196         case URL:
00197             p += sizedesc(buf+p);
00198             memcpy(buf+p, str, size);
00199             break;
00200         case SEQUENCE:
00201         case ALTERNATIVE: {
00202             if (sequence.size()==0) {//hack: should be solved in sizedesc
00203               buf[p++] |= 5;
00204               buf[p++] = 0;
00205               break;
00206             }
00207             int n = 0;
00208             p += sizedesc(buf+p);
00209             for (int i = 0; i < sequence.size(); i++)
00210                 n += sequence.at(i)->build(buf+p+n, max-p);
00211         }
00212         break;
00213     }
00214     p += size;
00215 //    printfBytes("Build:", buf, p);
00216     return p;
00217 }
00218 
00219 bool sdp_data::findUUID(unsigned uuid) {
00220     if (type == UUID)
00221         return asUnsigned()==uuid;
00222     if (type==SEQUENCE || type==ALTERNATIVE) {
00223         for (int i = 0; i < sequence.size(); i++) {
00224             if (sequence[i]->findUUID(uuid))
00225                 return true;
00226         }
00227     }
00228     return false;
00229 }