Lines Matching refs:blob
894 var blob = file.slice(0,512);
895 prep_blob(blob, 0);
898 var mv = check_get_mver(blob);
906 if(ssz !== 512) { blob = file.slice(0,ssz); prep_blob(blob, 28 /* blob.l */); }
910 check_shifts(blob, mver);
913 var nds = blob.read_shift(4, 'i');
918 blob.l += 4;
921 dir_start = blob.read_shift(4, 'i');
924 blob.l += 4;
927 blob.chk('00100000', 'Mini Stream Cutoff Size: ');
930 minifat_start = blob.read_shift(4, 'i');
933 nmfs = blob.read_shift(4, 'i');
936 difat_start = blob.read_shift(4, 'i');
939 ndfs = blob.read_shift(4, 'i');
943 q = blob.read_shift(4, 'i');
984 function check_get_mver(blob) { argument
986 blob.chk(HEADER_SIGNATURE, 'Header Signature: ');
989 blob.chk(HEADER_CLSID, 'CLSID: ');
992 var mver = blob.read_shift(2, 'u');
994 return [blob.read_shift(2,'u'), mver];
996 function check_shifts(blob, mver) { argument
1000 blob.chk('feff', 'Byte Order: ');
1003 switch((shift = blob.read_shift(2))) {
1010 blob.chk('0600', 'Mini Sector Shift: ');
1013 blob.chk('000000000000', 'Reserved: ');
1145 var blob;
1150 blob = sector.slice(i, i+128);
1151 prep_blob(blob, 64);
1152 namelen = blob.read_shift(2);
1154 name = __utf16le(blob,0,namelen-pl);
1158 type: blob.read_shift(1),
1159 color: blob.read_shift(1),
1160 L: blob.read_shift(4, 'i'),
1161 R: blob.read_shift(4, 'i'),
1162 C: blob.read_shift(4, 'i'),
1163 clsid: blob.read_shift(16),
1164 state: blob.read_shift(4, 'i')
1166 ctime = blob.read_shift(2) + blob.read_shift(2) + blob.read_shift(2) + blob.read_shift(2);
1168 o.ctime = ctime; o.ct = read_date(blob, blob.l-8);
1170 mtime = blob.read_shift(2) + blob.read_shift(2) + blob.read_shift(2) + blob.read_shift(2);
1172 o.mtime = mtime; o.mt = read_date(blob, blob.l-8);
1174 o.start = blob.read_shift(4, 'i');
1175 o.size = blob.read_shift(4, 'i');
1198 function read_date(blob, offset) {
1199 …return new Date(( ( (__readUInt32LE(blob,offset+4)/1e7)*Math.pow(2,32)+__readUInt32LE(blob,offset)…
1208 function readSync(blob, options) {
1210 case "file": return readFileSync(blob, options);
1211 case "base64": return parse(s2a(Base64.decode(blob)), options);
1212 case "binary": return parse(s2a(blob), options);
1214 return parse(blob);
1664 function prep_blob(blob, pos) { argument
1665 blob.l = pos;
1666 blob.read_shift = ReadShift;
1667 blob.chk = CheckField;
1668 blob.write_shift = WriteShift;
1671 function parsenoop(blob, length) { blob.l += length; } argument
1673 function writenoop(blob, length) { blob.l += length; } argument
2772 function parse_FILETIME(blob) { argument
2773 var dwLowDateTime = blob.read_shift(4), dwHighDateTime = blob.read_shift(4);
2778 function parse_lpstr(blob, type, pad) { argument
2779 var str = blob.read_shift(0, 'lpstr');
2780 if(pad) blob.l += (4 - ((str.length+1) & 3)) & 3;
2785 function parse_lpwstr(blob, type, pad) { argument
2786 var str = blob.read_shift(0, 'lpwstr');
2787 if(pad) blob.l += (4 - ((str.length+1) & 3)) & 3;
2794 function parse_VtStringBase(blob, stringType, pad) { argument
2795 if(stringType === 0x1F /*VT_LPWSTR*/) return parse_lpwstr(blob);
2796 return parse_lpstr(blob, stringType, pad);
2799 function parse_VtString(blob, t, pad) { return parse_VtStringBase(blob, t, pad === false ? 0: 4); } argument
2800 function parse_VtUnalignedString(blob, t) { if(!t) throw new Error("dafuq?"); return parse_VtString… argument
2803 function parse_VtVecUnalignedLpstrValue(blob) { argument
2804 var length = blob.read_shift(4);
2806 for(var i = 0; i != length; ++i) ret[i] = blob.read_shift(0, 'lpstr');
2811 function parse_VtVecUnalignedLpstr(blob) { argument
2812 return parse_VtVecUnalignedLpstrValue(blob);
2816 function parse_VtHeadingPair(blob) { argument
2817 var headingString = parse_TypedPropertyValue(blob, VT_USTR);
2818 var headerParts = parse_TypedPropertyValue(blob, VT_I4);
2823 function parse_VtVecHeadingPairValue(blob) { argument
2824 var cElements = blob.read_shift(4);
2826 for(var i = 0; i != cElements / 2; ++i) out.push(parse_VtHeadingPair(blob));
2831 function parse_VtVecHeadingPair(blob) { argument
2833 return parse_VtVecHeadingPairValue(blob);
2837 function parse_dictionary(blob,CodePage) { argument
2838 var cnt = blob.read_shift(4);
2841 var pid = blob.read_shift(4);
2842 var len = blob.read_shift(4);
2843 …dict[pid] = blob.read_shift(len, (CodePage === 0x4B0 ?'utf16le':'utf8')).replace(chr0,'').replace(…
2845 if(blob.l & 3) blob.l = (blob.l>>2+1)<<2;
2850 function parse_BLOB(blob) { argument
2851 var size = blob.read_shift(4);
2852 var bytes = blob.slice(blob.l,blob.l+size);
2853 if(size & 3 > 0) blob.l += (4 - (size & 3)) & 3;
2858 function parse_ClipboardData(blob) { argument
2861 o.Size = blob.read_shift(4);
2863 blob.l += o.Size;
2868 function parse_VtVector(blob, cb) { argument
2879 function parse_TypedPropertyValue(blob, type, _opts) { argument
2880 var t = blob.read_shift(2), ret, opts = _opts||{};
2881 blob.l += 2;
2885 case 0x02 /*VT_I2*/: ret = blob.read_shift(2, 'i'); if(!opts.raw) blob.l += 2; return ret;
2886 case 0x03 /*VT_I4*/: ret = blob.read_shift(4, 'i'); return ret;
2887 case 0x0B /*VT_BOOL*/: return blob.read_shift(4) !== 0x0;
2888 case 0x13 /*VT_UI4*/: ret = blob.read_shift(4); return ret;
2889 case 0x1E /*VT_LPSTR*/: return parse_lpstr(blob, t, 4).replace(chr0,'');
2890 case 0x1F /*VT_LPWSTR*/: return parse_lpwstr(blob);
2891 case 0x40 /*VT_FILETIME*/: return parse_FILETIME(blob);
2892 case 0x41 /*VT_BLOB*/: return parse_BLOB(blob);
2893 case 0x47 /*VT_CF*/: return parse_ClipboardData(blob);
2894 case 0x50 /*VT_STRING*/: return parse_VtString(blob, t, !opts.raw && 4).replace(chr0,'');
2895 case 0x51 /*VT_USTR*/: return parse_VtUnalignedString(blob, t, 4).replace(chr0,'');
2896 case 0x100C /*VT_VECTOR|VT_VARIANT*/: return parse_VtVecHeadingPair(blob);
2897 case 0x101E /*VT_LPSTR*/: return parse_VtVecUnalignedLpstr(blob);
2914 function parse_PropertySet(blob, PIDSI) { argument
2915 var start_addr = blob.l;
2916 var size = blob.read_shift(4);
2917 var NumProps = blob.read_shift(4);
2922 var PropID = blob.read_shift(4);
2923 var Offset = blob.read_shift(4);
2928 if(blob.l !== Props[i][1]) {
2931 … case 0x02 /*VT_I2*/: if(blob.l +2 === Props[i][1]) { blob.l+=2; fail = false; } break;
2932 … case 0x50 /*VT_STRING*/: if(blob.l <= Props[i][1]) { blob.l=Props[i][1]; fail = false; } break;
2933 …case 0x100C /*VT_VECTOR|VT_VARIANT*/: if(blob.l <= Props[i][1]) { blob.l=Props[i][1]; fail = false…
2935 if(!PIDSI && blob.l <= Props[i][1]) { fail=false; blob.l = Props[i][1]; }
2936 …if(fail) throw new Error("Read Error: Expected address " + Props[i][1] + ' at ' + blob.l + ' :' + …
2940 PropH[piddsi.n] = parse_TypedPropertyValue(blob, piddsi.t, {raw:true});
2972 CodePage = PropH.CodePage = parse_TypedPropertyValue(blob, VT_I2);
2975 var oldpos = blob.l;
2976 blob.l = Props[Dictionary][1];
2977 DictObj = parse_dictionary(blob,CodePage);
2978 blob.l = oldpos;
2981 if(CodePage === 0) { Dictionary = i; blob.l = Props[i+1][1]; continue; }
2982 DictObj = parse_dictionary(blob,CodePage);
2987 switch(blob[blob.l]) {
2988 case 0x41 /*VT_BLOB*/: blob.l += 4; val = parse_BLOB(blob); break;
2989 … case 0x1E /*VT_LPSTR*/: blob.l += 4; val = parse_VtString(blob, blob[blob.l-4]); break;
2990 … case 0x1F /*VT_LPWSTR*/: blob.l += 4; val = parse_VtString(blob, blob[blob.l-4]); break;
2991 case 0x03 /*VT_I4*/: blob.l += 4; val = blob.read_shift(4, 'i'); break;
2992 case 0x13 /*VT_UI4*/: blob.l += 4; val = blob.read_shift(4); break;
2993 case 0x05 /*VT_R8*/: blob.l += 4; val = blob.read_shift(8, 'f'); break;
2994 case 0x0B /*VT_BOOL*/: blob.l += 4; val = parsebool(blob, 4); break;
2995 … case 0x40 /*VT_FILETIME*/: blob.l += 4; val = new Date(parse_FILETIME(blob)); break;
2996 default: throw new Error("unparsed value: " + blob[blob.l]);
3002 blob.l = start_addr + size; /* step ahead to skip padding */
3008 var blob = file.content;
3009 prep_blob(blob, 0);
3012 blob.chk('feff', 'Byte Order: ');
3014 var vers = blob.read_shift(2); // TODO: check version
3015 var SystemIdentifier = blob.read_shift(4);
3016 blob.chk(CFB.utils.consts.HEADER_CLSID, 'CLSID: ');
3017 NumSets = blob.read_shift(4);
3019 FMTID0 = blob.read_shift(16); Offset0 = blob.read_shift(4);
3021 if(NumSets === 1 && Offset0 !== blob.l) throw "Length mismatch";
3022 else if(NumSets === 2) { FMTID1 = blob.read_shift(16); Offset1 = blob.read_shift(4); }
3023 var PSet0 = parse_PropertySet(blob, PIDSI);
3031 if(blob.l !== Offset1) throw "Length mismatch 2: " + blob.l + " !== " + Offset1;
3033 try { PSet1 = parse_PropertySet(blob, null); } catch(e) { }
3040 function parsenoop2(blob, length) { blob.read_shift(length); return null; } argument
3042 function parslurp(blob, length, cb) { argument
3043 var arr = [], target = blob.l + length;
3044 while(blob.l < target) arr.push(cb(blob, target - blob.l));
3045 if(target !== blob.l) throw new Error("Slurp error");
3049 function parslurp2(blob, length, cb) { argument
3050 var arr = [], target = blob.l + length, len = blob.read_shift(2);
3051 while(len-- !== 0) arr.push(cb(blob, target - blob.l));
3052 if(target !== blob.l) throw new Error("Slurp error");
3056 function parsebool(blob, length) { return blob.read_shift(length) === 0x1; } argument
3058 function parseuint16(blob) { return blob.read_shift(2, 'u'); } argument
3059 function parseuint16a(blob, length) { return parslurp(blob,length,parseuint16);} argument
3067 function parse_Bes(blob) { argument
3068 var v = blob.read_shift(1), t = blob.read_shift(1);
3073 function parse_ShortXLUnicodeString(blob, length, opts) { argument
3074 var cch = blob.read_shift(1);
3079 var fHighByte = blob.read_shift(1);
3082 var o = cch ? blob.read_shift(cch, encoding) : "";
3088 function parse_XLUnicodeRichExtendedString(blob) { argument
3091 var cch = blob.read_shift(2), flags = blob.read_shift(1);
3096 if(fRichSt) cRun = blob.read_shift(2);
3097 if(fExtSt) cbExtRst = blob.read_shift(4);
3099 var msg = cch === 0 ? "" : blob.read_shift(cch, encoding);
3100 if(fRichSt) blob.l += 4 * cRun; //TODO: parse this
3101 if(fExtSt) blob.l += cbExtRst; //TODO: parse this
3109 function parse_XLUnicodeStringNoCch(blob, cch, opts) { argument
3111 var fHighByte = blob.read_shift(1);
3112 if(fHighByte===0) { retval = blob.read_shift(cch, 'sbcs-cont'); }
3113 else { retval = blob.read_shift(cch, 'dbcs-cont'); }
3118 function parse_XLUnicodeString(blob, length, opts) { argument
3119 var cch = blob.read_shift(opts !== undefined && opts.biff > 0 && opts.biff < 8 ? 1 : 2);
3120 if(cch === 0) { blob.l++; return ""; }
3121 return parse_XLUnicodeStringNoCch(blob, cch, opts);
3124 function parse_XLUnicodeString2(blob, length, opts) { argument
3125 if(opts.biff !== 5 && opts.biff !== 2) return parse_XLUnicodeString(blob, length, opts);
3126 var cch = blob.read_shift(1);
3127 if(cch === 0) { blob.l++; return ""; }
3128 return blob.read_shift(cch, 'sbcs-cont');
3135 var parse_URLMoniker = function(blob, length) { argument
3136 var len = blob.read_shift(4), start = blob.l;
3140 blob.l += len - 24;
3141 if(blob.read_shift(16) === "795881f43b1d7f48af2c825dc4852763") extra = true;
3142 blob.l = start;
3144 var url = blob.read_shift((extra?len-24:len)>>1, 'utf16le').replace(chr0,"");
3145 if(extra) blob.l += 24;
3150 var parse_FileMoniker = function(blob, length) { argument
3151 var cAnti = blob.read_shift(2);
3152 var ansiLength = blob.read_shift(4);
3153 var ansiPath = blob.read_shift(ansiLength, 'cstr');
3154 var endServer = blob.read_shift(2);
3155 var versionNumber = blob.read_shift(2);
3156 var cbUnicodePathSize = blob.read_shift(4);
9206 function slurp(R, blob, length, opts) { argument
9209 var d = blob.slice(blob.l,blob.l+l);
9217 blob.l += l;
9218 var next = (XLSRecordEnum[__readUInt16LE(blob,blob.l)]);
9220 l = __readUInt16LE(blob,blob.l+2);
9221 bufs.push(blob.slice(blob.l+4,blob.l+4+l));
9222 blob.l += 4+l;
9223 next = (XLSRecordEnum[__readUInt16LE(blob, blob.l)]);
9254 function parse_workbook(blob, options) { argument
9331 while(blob.l < blob.length - 1) {
9332 var s = blob.l;
9333 var RecordType = blob.read_shift(2);
9335 var length = (blob.l === blob.length ? 0 : blob.read_shift(2)), y;
9343 var rt = blob.read_shift(2); length -= 2;
9345 if(R.r == 12){ blob.l += 10; length -= 10; } // skip FRT
9349 if(R.n === 'EOF') val = R.f(blob, length, opts);
9350 else val = slurp(R, blob, length, opts);
9362 if(!opts.enc) blob.l = 0;
9791 } else blob.l += length;