func UnmarshalStream(url string, reader io.Reader) (feed *Feed, err error) { // Read the stream into memory (we'll need to parse it twice) var contentReader *bytes.Reader var content []byte if content, err = ioutil.ReadAll(reader); err == nil { contentReader = bytes.NewReader(content) genericFeed := GenericFeed{} decoder := xml.NewDecoder(contentReader) decoder.CharsetReader = charset.NewReader // First pass - parse the feed as-is if err = decoder.Decode(&genericFeed); err != nil { // Error - check for invalid entities and correct as appropriate if fixed, fixedContent := fixEntities(content); fixed { // At least one replacement was made. Retry contentReader = bytes.NewReader(fixedContent) decoder = xml.NewDecoder(contentReader) decoder.CharsetReader = charset.NewReader // Try decoding again err = decoder.Decode(&genericFeed) } } if err != nil { return } var xmlFeed FeedMarshaler if genericFeed.XMLName.Space == "http://www.w3.org/1999/02/22-rdf-syntax-ns#" && genericFeed.XMLName.Local == "RDF" { xmlFeed = &rss1Feed{} } else if genericFeed.XMLName.Local == "rss" { xmlFeed = &rss2Feed{} } else if genericFeed.XMLName.Space == "http://www.w3.org/2005/Atom" && genericFeed.XMLName.Local == "feed" { xmlFeed = &atomFeed{} } else { err = errors.New("Unsupported type of feed (" + genericFeed.XMLName.Space + ":" + genericFeed.XMLName.Local + ")") return } contentReader.Seek(0, 0) decoder = xml.NewDecoder(contentReader) decoder.CharsetReader = charset.NewReader if err = decoder.Decode(xmlFeed); err == nil { if feed, err = xmlFeed.Marshal(); err == nil { feed.URL = url } } } return }
func UnmarshalStream(reader io.Reader) (*Feed, string, error) { format := "" // Read the stream into memory (we'll need to parse it twice) var contentReader *bytes.Reader if buffer, err := ioutil.ReadAll(reader); err == nil { contentReader = bytes.NewReader(buffer) } else { return nil, format, err } genericFeed := GenericFeed{} decoder := xml.NewDecoder(contentReader) decoder.CharsetReader = charsetReader if err := decoder.Decode(&genericFeed); err != nil { return nil, format, err } var xmlFeed FeedMarshaler if genericFeed.XMLName.Space == "http://www.w3.org/1999/02/22-rdf-syntax-ns#" && genericFeed.XMLName.Local == "RDF" { xmlFeed = &rss1Feed{} format = "RSS1" } else if genericFeed.XMLName.Local == "rss" { xmlFeed = &rss2Feed{} format = "RSS2" } else if genericFeed.XMLName.Space == "http://www.w3.org/2005/Atom" && genericFeed.XMLName.Local == "feed" { xmlFeed = &atomFeed{} format = "Atom" } else { return nil, format, errors.New("Unsupported type of feed (" + genericFeed.XMLName.Space + ":" + genericFeed.XMLName.Local + ")") } contentReader.Seek(0, 0) decoder = xml.NewDecoder(contentReader) decoder.CharsetReader = charsetReader if err := decoder.Decode(xmlFeed); err != nil { return nil, format, err } feed, err := xmlFeed.Marshal() if err != nil { return nil, format, err } return &feed, format, nil }
// Returns the root node of a tree of valid element names func names(rdr io.Reader) *name { var n = new(name) ns := make(map[string]bool) decoder := xml.NewDecoder(rdr) decoder.Strict = false for tok, err := decoder.RawToken(); err != io.EOF; tok, err = decoder.RawToken() { // if it breaks, try again! if err != nil { decoder = xml.NewDecoder(rdr) decoder.Strict = false continue } switch el := tok.(type) { case xml.StartElement: if _, ok := ns[el.Name.Local]; !ok { ns[el.Name.Local] = false } case xml.EndElement: if _, ok := ns[el.Name.Local]; ok { ns[el.Name.Local] = true } } } for k, v := range ns { if v { n.add([]byte(k)) } } // add the XML declaration to the list of valid names (a bit of a hack) n.add([]byte("?xml version=\"1.0\"?")) return n }
func respIsOk(sVueResp *SVUEResponse, expectedElement string) (*xml.Decoder, error) { d := xml.NewDecoder(strings.NewReader(sVueResp.Result)) TokenLoop: for { t, err := d.Token() if err == io.EOF { return nil, SVUEError{ OrigError: err, Code: DecodingError, } } if _t, ok := t.(xml.StartElement); ok { switch _t.Name.Local { case expectedElement: break TokenLoop case "RT_ERROR": return nil, decodeRespError(sVueResp) default: continue TokenLoop } } else { continue } } return xml.NewDecoder(strings.NewReader(sVueResp.Result)), nil }
func loadConfig(dirName string) (*objects.Core, error) { dir, err := os.Open(os.ExpandEnv(dirName)) if err != nil { return nil, err } s, err := dir.Stat() if err != nil { return nil, err } cfg := &objects.Core{} if !s.IsDir() { decoder := xml.NewDecoder(dir) err = decoder.Decode(&cfg) return cfg, err } files, err := dir.Readdir(-1) if err != nil { return nil, err } sort.Sort(FilesByName(files)) for _, fInfo := range files { file, err := os.Open(dirName + fInfo.Name()) if err != nil { return nil, err } decoder := xml.NewDecoder(file) err = decoder.Decode(&cfg) if err != nil { return nil, fmt.Errorf("Decoding %s: %s", fInfo.Name(), err.Error()) } } return cfg, nil }
func (l *LibSuite) TestReadRowsFromSheetWithMergeCells(c *C) { var sharedstringsXML = bytes.NewBufferString(` <?xml version="1.0" encoding="UTF-8" standalone="yes"?> <sst xmlns="http://schemas.openxmlformats.org/spreadsheetml/2006/main" count="3" uniqueCount="3"> <si> <t>Value A</t> </si> <si> <t>Value B</t> </si> <si> <t>Value C</t> </si> </sst> `) var sheetxml = bytes.NewBufferString(` <?xml version="1.0" encoding="UTF-8" standalone="yes"?> <worksheet xmlns="http://schemas.openxmlformats.org/spreadsheetml/2006/main" xmlns:r="http://schemas.openxmlformats.org/officeDocument/2006/relationships" xmlns:mx="http://schemas.microsoft.com/office/mac/excel/2008/main" xmlns:mc="http://schemas.openxmlformats.org/markup-compatibility/2006" xmlns:mv="urn:schemas-microsoft-com:mac:vml" xmlns:x14="http://schemas.microsoft.com/office/spreadsheetml/2009/9/main" xmlns:x14ac="http://schemas.microsoft.com/office/spreadsheetml/2009/9/ac" xmlns:xm="http://schemas.microsoft.com/office/excel/2006/main"> <sheetViews> <sheetView workbookViewId="0"/> </sheetViews> <sheetFormatPr customHeight="1" defaultColWidth="17.29" defaultRowHeight="15.0"/> <cols> <col customWidth="1" min="1" max="6" width="14.43"/> </cols> <sheetData> <row r="1" ht="15.75" customHeight="1"> <c r="A1" s="1" t="s"> <v>0</v> </c> </row> <row r="2" ht="15.75" customHeight="1"> <c r="A2" s="1" t="s"> <v>1</v> </c> <c r="B2" s="1" t="s"> <v>2</v> </c> </row> </sheetData> <mergeCells count="1"> <mergeCell ref="A1:B1"/> </mergeCells> <drawing r:id="rId1"/> </worksheet>`) worksheet := new(xlsxWorksheet) err := xml.NewDecoder(sheetxml).Decode(worksheet) c.Assert(err, IsNil) sst := new(xlsxSST) err = xml.NewDecoder(sharedstringsXML).Decode(sst) c.Assert(err, IsNil) file := new(File) file.referenceTable = MakeSharedStringRefTable(sst) sheet := new(Sheet) rows, _, _, _ := readRowsFromSheet(worksheet, file, sheet) row := rows[0] // cell1 := row.Cells[0] c.Assert(cell1.HMerge, Equals, 1) c.Assert(cell1.VMerge, Equals, 0) }
func processIQ(stanza *xmpp.ClientIQ) interface{} { buf := bytes.NewBuffer(stanza.Query) parser := xml.NewDecoder(buf) token, _ := parser.Token() if token == nil { return nil } startElem, ok := token.(xml.StartElement) if !ok { return nil } switch startElem.Name.Local { case "update_contacts": var contacts ConfigContacts if err := xml.NewDecoder(bytes.NewBuffer(stanza.Query)).Decode(&contacts); err != nil { log.Print("Failed to parse IQ for ConfigContacts") return nil } for _, contact := range contacts.Contacts { handleContact(contact) } return xmpp.EmptyReply{} default: log.Print("Unknown IQ: ", startElem.Name.Local) } return nil }
func (s *SQSRequest) CreateQueue(queueName string, options map[string]string) (*QueueURLResponse, error) { params := map[string]string{ "Action": "CreateQueue", "QueueName": queueName, } count := 1 for name, value := range options { params[fmt.Sprintf("Attribute.%d.Name", count)] = name params[fmt.Sprintf("Attribute.%d.Value", count)] = value count++ } reader, err := s.makeSQSAdminRequest(params) if err != nil { er := new(ErrorResponse) xml.NewDecoder(reader).Decode(er) log.Println(er) return nil, err } qur := new(QueueURLResponse) if err = xml.NewDecoder(reader).Decode(qur); err != nil { return nil, err } return qur, nil }
func (v *Vsphere) call(body string, dst interface{}) error { buf := new(bytes.Buffer) buf.WriteString(soapPre) buf.WriteString(body) buf.WriteString(soapPost) req, err := http.NewRequest("POST", v.url.String(), buf) if err != nil { return err } for k, v := range v.header { req.Header[k] = v } for _, c := range v.cookies.Cookies(v.url) { req.AddCookie(c) } resp, err := v.client.Do(req) if err != nil { return err } v.cookies.SetCookies(v.url, resp.Cookies()) defer resp.Body.Close() if resp.StatusCode == 500 { var e Error if err := xml.NewDecoder(resp.Body).Decode(&e); err != nil { return fmt.Errorf("vsphere: bad response, could not decode error: %v", err) } return e } else if resp.StatusCode != 200 { return fmt.Errorf("vsphere: bad status code %v", resp.Status) } if dst != nil { return xml.NewDecoder(resp.Body).Decode(dst) } return nil }
// startStream will start a new XML decoder for the connection, signal the start of a stream to the server and verify that the server has // also started the stream; if o.Debug is true, startStream will tee decoded XML data to stderr. The features advertised by the server // will be returned. func (c *Client) startStream(o *Options, domain string) (*streamFeatures, error) { if o.Debug { c.p = xml.NewDecoder(tee{c.conn, os.Stderr}) } else { c.p = xml.NewDecoder(c.conn) } _, err := fmt.Fprintf(c.conn, "<?xml version='1.0'?>\n"+ "<stream:stream to='%s' xmlns='%s'\n"+ " xmlns:stream='%s' version='1.0'>\n", xmlEscape(domain), nsClient, nsStream) if err != nil { return nil, err } // We expect the server to start a <stream>. se, err := nextStart(c.p) if err != nil { return nil, err } if se.Name.Space != nsStream || se.Name.Local != "stream" { return nil, fmt.Errorf("expected <stream> but got <%v> in %v", se.Name.Local, se.Name.Space) } // Now we're in the stream and can use Unmarshal. // Next message should be <features> to tell us authentication options. // See section 4.6 in RFC 3920. f := new(streamFeatures) if err = c.p.DecodeElement(f, nil); err != nil { return f, errors.New("unmarshal <features>: " + err.Error()) } return f, nil }
func (v *VCloudSession) FindOrganisations(max_page_size, max_pages int) (Orgs []*Organisation, err error) { if max_page_size <= 0 { max_page_size = 1 } if max_pages <= 0 { max_pages = 1 } for i := 1; i <= max_pages; i++ { page := &OrgReferences{} uri := fmt.Sprintf("/api/query?type=organization&format=references&pageSize=%v&page=%v", max_page_size, i) r, err := v.Get(uri) if err != nil { continue } defer r.Body.Close() if r.StatusCode == 400 { break } _ = xml.NewDecoder(r.Body).Decode(page) for _, record := range page.Records { u, _ := url.Parse(record.Href) r, err := v.Get(u.Path) if err != nil { continue } defer r.Body.Close() if r.StatusCode != 200 { continue } new_org := &Organisation{} _ = xml.NewDecoder(r.Body).Decode(new_org) for k, val := range new_org.Links { u, _ := url.Parse(val.Href) new_org.Links[k].Href = u.Path } Orgs = append(Orgs, new_org) } } if len(Orgs) <= 0 { return Orgs, errors.New("No organisations returned.") } else { return Orgs, nil } }
func (l *LibSuite) TestReadRowsFromSheetWithHiddenColumn(c *C) { var sharedstringsXML = bytes.NewBufferString(` <?xml version="1.0" encoding="UTF-8" standalone="yes"?> <sst xmlns="http://schemas.openxmlformats.org/spreadsheetml/2006/main"> <si><t>This is a test.</t></si> <si><t>This should be invisible.</t></si> </sst>`) var sheetxml = bytes.NewBufferString(` <?xml version="1.0" encoding="UTF-8" standalone="yes"?> <worksheet xmlns:mc="http://schemas.openxmlformats.org/markup-compatibility/2006" xmlns:mv="urn:schemas-microsoft-com:mac:vml" xmlns:mx="http://schemas.microsoft.com/office/mac/excel/2008/main" xmlns:r="http://schemas.openxmlformats.org/officeDocument/2006/relationships" xmlns:x14="http://schemas.microsoft.com/office/spreadsheetml/2009/9/main" xmlns:x14ac="http://schemas.microsoft.com/office/spreadsheetml/2009/9/ac" xmlns:xm="http://schemas.microsoft.com/office/excel/2006/main" xmlns="http://schemas.openxmlformats.org/spreadsheetml/2006/main"> <sheetViews><sheetView workbookViewId="0"/> </sheetViews> <sheetFormatPr customHeight="1" defaultColWidth="14.43" defaultRowHeight="15.75"/> <cols> <col hidden="1" max="2" min="2"/> </cols> <sheetData> <row r="1"> <c r="A1" s="1" t="s"><v>0</v></c> <c r="B1" s="1" t="s"><v>1</v></c> </row> </sheetData><drawing r:id="rId1"/></worksheet>`) worksheet := new(xlsxWorksheet) err := xml.NewDecoder(sheetxml).Decode(worksheet) c.Assert(err, IsNil) sst := new(xlsxSST) err = xml.NewDecoder(sharedstringsXML).Decode(sst) c.Assert(err, IsNil) file := new(File) file.referenceTable = MakeSharedStringRefTable(sst) sheet := new(Sheet) rows, _, maxCols, maxRows := readRowsFromSheet(worksheet, file, sheet) c.Assert(maxRows, Equals, 1) c.Assert(maxCols, Equals, 2) row := rows[0] c.Assert(row.Sheet, Equals, sheet) c.Assert(len(row.Cells), Equals, 2) cell1 := row.Cells[0] c.Assert(cell1.Type(), Equals, CellTypeString) if val, err := cell1.String(); err != nil { c.Error(err) } else { c.Assert(val, Equals, "This is a test.") } c.Assert(cell1.Hidden, Equals, false) cell2 := row.Cells[1] c.Assert(cell2.Type(), Equals, CellTypeString) if val, err := cell2.String(); err != nil { c.Error(err) } else { c.Assert(val, Equals, "This should be invisible.") } c.Assert(cell2.Hidden, Equals, true) }
func (l *LibSuite) TestReadRowsFromSheetWithTrailingEmptyCells(c *C) { var row *Row var cell1, cell2, cell3, cell4 *Cell var sharedstringsXML = bytes.NewBufferString(` <?xml version="1.0" encoding="UTF-8" standalone="yes"?> <sst xmlns="http://schemas.openxmlformats.org/spreadsheetml/2006/main" count="4" uniqueCount="4"><si><t>A</t></si><si><t>B</t></si><si><t>C</t></si><si><t>D</t></si></sst>`) var sheetxml = bytes.NewBufferString(` <?xml version="1.0" encoding="UTF-8" standalone="yes"?> <worksheet xmlns="http://schemas.openxmlformats.org/spreadsheetml/2006/main" xmlns:r="http://schemas.openxmlformats.org/officeDocument/2006/relationships"><dimension ref="A1:D8"/><sheetViews><sheetView tabSelected="1" workbookViewId="0"><selection activeCell="A7" sqref="A7"/></sheetView></sheetViews><sheetFormatPr baseColWidth="10" defaultRowHeight="15"/><sheetData><row r="1" spans="1:4"><c r="A1" t="s"><v>0</v></c><c r="B1" t="s"><v>1</v></c><c r="C1" t="s"><v>2</v></c><c r="D1" t="s"><v>3</v></c></row><row r="2" spans="1:4"><c r="A2"><v>1</v></c></row><row r="3" spans="1:4"><c r="B3"><v>1</v></c></row><row r="4" spans="1:4"><c r="C4"><v>1</v></c></row><row r="5" spans="1:4"><c r="D5"><v>1</v></c></row><row r="6" spans="1:4"><c r="C6"><v>1</v></c></row><row r="7" spans="1:4"><c r="B7"><v>1</v></c></row><row r="8" spans="1:4"><c r="A8"><v>1</v></c></row></sheetData><pageMargins left="0.7" right="0.7" top="0.78740157499999996" bottom="0.78740157499999996" header="0.3" footer="0.3"/></worksheet> `) worksheet := new(xlsxWorksheet) err := xml.NewDecoder(sheetxml).Decode(worksheet) c.Assert(err, IsNil) sst := new(xlsxSST) err = xml.NewDecoder(sharedstringsXML).Decode(sst) c.Assert(err, IsNil) file := new(File) file.referenceTable = MakeSharedStringRefTable(sst) sheet := new(Sheet) rows, _, maxCol, maxRow := readRowsFromSheet(worksheet, file, sheet) c.Assert(maxCol, Equals, 4) c.Assert(maxRow, Equals, 8) row = rows[0] c.Assert(row.Sheet, Equals, sheet) c.Assert(len(row.Cells), Equals, 4) cell1 = row.Cells[0] c.Assert(cell1.Value, Equals, "A") cell2 = row.Cells[1] c.Assert(cell2.Value, Equals, "B") cell3 = row.Cells[2] c.Assert(cell3.Value, Equals, "C") cell4 = row.Cells[3] c.Assert(cell4.Value, Equals, "D") row = rows[1] c.Assert(row.Sheet, Equals, sheet) c.Assert(len(row.Cells), Equals, 4) cell1 = row.Cells[0] c.Assert(cell1.Value, Equals, "1") cell2 = row.Cells[1] c.Assert(cell2.Value, Equals, "") cell3 = row.Cells[2] c.Assert(cell3.Value, Equals, "") cell4 = row.Cells[3] c.Assert(cell4.Value, Equals, "") }
func (l *LibSuite) TestRowNotOverwrittenWhenFollowedByEmptyRow(c *C) { sheetXML := bytes.NewBufferString(` <?xml version="1.0" encoding="UTF-8"?> <worksheet xmlns="http://schemas.openxmlformats.org/spreadsheetml/2006/main" xmlns:mc="http://schemas.openxmlformats.org/markup-compatibility/2006" xmlns:mv="urn:schemas-microsoft-com:mac:vml" xmlns:mx="http://schemas.microsoft.com/office/mac/excel/2008/main" xmlns:r="http://schemas.openxmlformats.org/officeDocument/2006/relationships" xmlns:x14="http://schemas.microsoft.com/office/spreadsheetml/2009/9/main" xmlns:x14ac="http://schemas.microsoft.com/office/spreadsheetml/2009/9/ac" xmlns:xm="http://schemas.microsoft.com/office/excel/2006/main"> <sheetViews> <sheetView workbookViewId="0" /> </sheetViews> <sheetFormatPr customHeight="1" defaultColWidth="14.43" defaultRowHeight="15.75" /> <sheetData> <row r="2"> <c r="A2" t="str"> <f t="shared" ref="A2" si="1">RANDBETWEEN(1,100)</f> <v>66</v> </c> </row> <row r="3"> <c r="A3" t="str"> <f t="shared" ref="A3" si="2">RANDBETWEEN(1,100)</f> <v>30</v> </c> </row> <row r="4"> <c r="A4" t="str"> <f t="shared" ref="A4" si="3">RANDBETWEEN(1,100)</f> <v>75</v> </c> </row> <row r="7"> <c r="A7" s="1" t="str"> <f t="shared" ref="A7" si="4">A4/A2</f> <v>1.14</v> </c> </row> </sheetData> <drawing r:id="rId1" /> </worksheet> `) sharedstringsXML := bytes.NewBufferString(`<?xml version="1.0" encoding="UTF-8" standalone="yes"?><sst xmlns="http://schemas.openxmlformats.org/spreadsheetml/2006/main"/>`) worksheet := new(xlsxWorksheet) xml.NewDecoder(sheetXML).Decode(worksheet) sst := new(xlsxSST) xml.NewDecoder(sharedstringsXML).Decode(sst) file := new(File) file.referenceTable = MakeSharedStringRefTable(sst) sheet := new(Sheet) rows, _, _, _ := readRowsFromSheet(worksheet, file, sheet) cells := rows[3].Cells c.Assert(cells, HasLen, 1) c.Assert(cells[0].Value, Equals, "75") }
func (s *MyAPIDonutCacheSuite) TestBucketMultipartList(c *C) { request, err := http.NewRequest("PUT", testAPIDonutCacheServer.URL+"/bucketmultipartlist", bytes.NewBufferString("")) c.Assert(err, IsNil) setDummyAuthHeader(request) client := http.Client{} response, err := client.Do(request) c.Assert(err, IsNil) c.Assert(response.StatusCode, Equals, 200) request, err = http.NewRequest("POST", testAPIDonutCacheServer.URL+"/bucketmultipartlist/object?uploads", bytes.NewBufferString("")) c.Assert(err, IsNil) setDummyAuthHeader(request) response, err = client.Do(request) c.Assert(response.StatusCode, Equals, http.StatusOK) decoder := xml.NewDecoder(response.Body) newResponse := &api.InitiateMultipartUploadResult{} err = decoder.Decode(newResponse) c.Assert(err, IsNil) c.Assert(len(newResponse.UploadID) > 0, Equals, true) uploadID := newResponse.UploadID request, err = http.NewRequest("PUT", testAPIDonutCacheServer.URL+"/bucketmultipartlist/object?uploadId="+uploadID+"&partNumber=1", bytes.NewBufferString("hello world")) c.Assert(err, IsNil) setDummyAuthHeader(request) response1, err := client.Do(request) c.Assert(err, IsNil) c.Assert(response1.StatusCode, Equals, http.StatusOK) request, err = http.NewRequest("PUT", testAPIDonutCacheServer.URL+"/bucketmultipartlist/object?uploadId="+uploadID+"&partNumber=2", bytes.NewBufferString("hello world")) c.Assert(err, IsNil) setDummyAuthHeader(request) response2, err := client.Do(request) c.Assert(err, IsNil) c.Assert(response2.StatusCode, Equals, http.StatusOK) request, err = http.NewRequest("GET", testAPIDonutCacheServer.URL+"/bucketmultipartlist?uploads", nil) c.Assert(err, IsNil) setDummyAuthHeader(request) response3, err := client.Do(request) c.Assert(err, IsNil) c.Assert(response3.StatusCode, Equals, http.StatusOK) decoder = xml.NewDecoder(response3.Body) newResponse3 := &api.ListMultipartUploadsResponse{} err = decoder.Decode(newResponse3) c.Assert(err, IsNil) c.Assert(newResponse3.Bucket, Equals, "bucketmultipartlist") }
func (l *LibSuite) TestReadRowsFromSheetWithLeadingEmptyRows(c *C) { var sharedstringsXML = bytes.NewBufferString(`<?xml version="1.0" encoding="UTF-8" standalone="yes"?> <sst xmlns="http://schemas.openxmlformats.org/spreadsheetml/2006/main" count="2" uniqueCount="2"><si><t>ABC</t></si><si><t>DEF</t></si></sst>`) var sheetxml = bytes.NewBufferString(`<?xml version="1.0" encoding="UTF-8" standalone="yes"?> <worksheet xmlns="http://schemas.openxmlformats.org/spreadsheetml/2006/main" xmlns:r="http://schemas.openxmlformats.org/officeDocument/2006/relationships" xmlns:mc="http://schemas.openxmlformats.org/markup-compatibility/2006" mc:Ignorable="x14ac" xmlns:x14ac="http://schemas.microsoft.com/office/spreadsheetml/2009/9/ac"> <dimension ref="A4:A5"/> <sheetViews> <sheetView tabSelected="1" workbookViewId="0"> <selection activeCell="A2" sqref="A2"/> </sheetView> </sheetViews> <sheetFormatPr baseColWidth="10" defaultRowHeight="15" x14ac:dyDescent="0"/> <sheetData> <row r="4" spans="1:1"> <c r="A4" t="s"> <v>0</v> </c> </row> <row r="5" spans="1:1"> <c r="A5" t="s"> <v>1</v> </c> </row> </sheetData> <pageMargins left="0.75" right="0.75" top="1" bottom="1" header="0.5" footer="0.5"/> <pageSetup paperSize="9" orientation="portrait" horizontalDpi="4294967292" verticalDpi="4294967292"/> <extLst> <ext uri="{64002731-A6B0-56B0-2670-7721B7C09600}" xmlns:mx="http://schemas.microsoft.com/office/mac/excel/2008/main"> <mx:PLV Mode="0" OnePage="0" WScale="0"/> </ext> </extLst> </worksheet> `) worksheet := new(xlsxWorksheet) err := xml.NewDecoder(sheetxml).Decode(worksheet) c.Assert(err, IsNil) sst := new(xlsxSST) err = xml.NewDecoder(sharedstringsXML).Decode(sst) c.Assert(err, IsNil) file := new(File) file.referenceTable = MakeSharedStringRefTable(sst) sheet := new(Sheet) rows, _, maxCols, maxRows := readRowsFromSheet(worksheet, file, sheet) c.Assert(maxRows, Equals, 5) c.Assert(maxCols, Equals, 1) c.Assert(len(rows[0].Cells), Equals, 0) c.Assert(len(rows[1].Cells), Equals, 0) c.Assert(len(rows[2].Cells), Equals, 0) c.Assert(len(rows[3].Cells), Equals, 1) c.Assert(rows[3].Cells[0].String(), Equals, "ABC") c.Assert(len(rows[4].Cells), Equals, 1) c.Assert(rows[4].Cells[0].String(), Equals, "DEF") }
func readDatabase(path string) (*Database, error) { db := Database{} if strings.HasPrefix(path, "http://") || strings.HasPrefix(path, "https://") { resp, err := http.Get(DBFILE) if err != nil { return nil, fmt.Errorf("cannot fetch database file (%s): %s", DBFILE, err) } defer resp.Body.Close() if err := xml.NewDecoder(resp.Body).Decode(&db); err != nil { return nil, err } } else { f, err := os.Open(path) if err != nil { return nil, err } defer f.Close() if err := xml.NewDecoder(f).Decode(&db); err != nil { return nil, err } } if len(db.Signatures) == 0 { return nil, fmt.Errorf("no signatures loaded, check file format") } for i, sig := range db.Signatures { r, err := regexp.Compile(sig.Signature) if err != nil { return nil, fmt.Errorf("failed to compile signature %d regexp %q: %v", sig.Id, sig.Signature, err) } db.Signatures[i].Regexp = r } if SKIPSOFT { var count int for _, sig := range db.Signatures { if sig.Type == "c" { count++ } } critSignatures := make([]Signature, 0, count) for _, sig := range db.Signatures { if sig.Type == "c" { critSignatures = append(critSignatures, sig) } } return &Database{critSignatures}, nil } return &db, nil }
func (s *Session) setConn(conn net.Conn) { s.conn = conn if s.srv.cfg.DebugEnable { s.dec = xml.NewDecoder(readTunnel{s.conn, os.Stdout}) s.w = writeTunnel{s.conn, os.Stdout} } else { s.dec = xml.NewDecoder(s.conn) s.w = s.conn } s.enc = xml.NewEncoder(s.conn) }
// acceptTypeDecoder provide decoded value in given acceptType func acceptTypeDecoder(body io.Reader, acceptType string, v interface{}) error { var d decoder switch { case acceptType == "application/xml": d = xml.NewDecoder(body) case acceptType == "application/json": d = json.NewDecoder(body) default: d = xml.NewDecoder(body) } return d.Decode(v) }
func (s *MyAPIFSCacheSuite) TestBucketMultipartList(c *C) { request, err := s.newRequest("PUT", testAPIFSCacheServer.URL+"/bucketmultipartlist", 0, nil) c.Assert(err, IsNil) client := http.Client{} response, err := client.Do(request) c.Assert(err, IsNil) c.Assert(response.StatusCode, Equals, 200) request, err = s.newRequest("POST", testAPIFSCacheServer.URL+"/bucketmultipartlist/object?uploads", 0, nil) c.Assert(err, IsNil) response, err = client.Do(request) c.Assert(response.StatusCode, Equals, http.StatusOK) decoder := xml.NewDecoder(response.Body) newResponse := &InitiateMultipartUploadResponse{} err = decoder.Decode(newResponse) c.Assert(err, IsNil) c.Assert(len(newResponse.UploadID) > 0, Equals, true) uploadID := newResponse.UploadID buffer1 := bytes.NewReader([]byte("hello world")) request, err = s.newRequest("PUT", testAPIFSCacheServer.URL+"/bucketmultipartlist/object?uploadId="+uploadID+"&partNumber=1", int64(buffer1.Len()), buffer1) c.Assert(err, IsNil) response1, err := client.Do(request) c.Assert(err, IsNil) c.Assert(response1.StatusCode, Equals, http.StatusOK) buffer2 := bytes.NewReader([]byte("hello world")) request, err = s.newRequest("PUT", testAPIFSCacheServer.URL+"/bucketmultipartlist/object?uploadId="+uploadID+"&partNumber=2", int64(buffer2.Len()), buffer2) c.Assert(err, IsNil) response2, err := client.Do(request) c.Assert(err, IsNil) c.Assert(response2.StatusCode, Equals, http.StatusOK) request, err = s.newRequest("GET", testAPIFSCacheServer.URL+"/bucketmultipartlist?uploads", 0, nil) c.Assert(err, IsNil) response3, err := client.Do(request) c.Assert(err, IsNil) c.Assert(response3.StatusCode, Equals, http.StatusOK) decoder = xml.NewDecoder(response3.Body) newResponse3 := &ListMultipartUploadsResponse{} err = decoder.Decode(newResponse3) c.Assert(err, IsNil) c.Assert(newResponse3.Bucket, Equals, "bucketmultipartlist") }
func X2J(filename string) []byte { //(n xmlNode) { var n xmlNode b, _ := ioutil.ReadFile(filename) reader := strings.NewReader(Elementize(xml.NewDecoder(strings.NewReader(string(b))))) xml.NewDecoder(reader).Decode(&n) var y []interface{} for _, v := range n.Nodes { y = append(y, v.walk()) } j, _ := json.Marshal(y) return j }
func handleSAML(w http.ResponseWriter, r *http.Request) { resp := server.NewResponse() defer resp.Close() defer func() { err := osin.OutputJSON(resp, w, r) if err != nil { log.Println("error finishing authZ request", err) } }() if ar := server.HandleAuthorizeRequest(resp, r); ar != nil { defer server.FinishAuthorizeRequest(resp, r, ar) err := r.ParseForm() if err != nil { log.Println(err) } sr := r.Form.Get("SAMLResponse") bs, err := base64.StdEncoding.DecodeString(sr) if err != nil { log.Println("Error decoding base64", err) } var res saml.Response err = xml.NewDecoder(bytes.NewBuffer(bs)).Decode(&res) if err != nil { log.Println(err) return } pt, err := res.Decrypt(cert) if err != nil { log.Println("error decrypting saml:", err) return } var a saml.Assertion err = xml.NewDecoder(bytes.NewBuffer(pt)).Decode(&a) if err != nil { log.Println(err) return } ar.UserData = a ar.Authorized = true } }
func (r *Request) decodeEntity(reader io.Reader, contentType string, entityPointer interface{}) (err error) { if strings.Contains(contentType, MIME_XML) { return xml.NewDecoder(reader).Decode(entityPointer) } if strings.Contains(contentType, MIME_JSON) || MIME_JSON == defaultRequestContentType { decoder := json.NewDecoder(reader) decoder.UseNumber() return decoder.Decode(entityPointer) } if MIME_XML == defaultRequestContentType { return xml.NewDecoder(reader).Decode(entityPointer) } return NewError(400, "Unable to unmarshal content of type:"+contentType) }
func makeInOut(conn io.ReadWriter, config *Config) (in *xml.Decoder, out io.Writer) { if config != nil && config.InLog != nil { in = xml.NewDecoder(io.TeeReader(conn, config.InLog)) } else { in = xml.NewDecoder(conn) } if config != nil && config.OutLog != nil { out = io.MultiWriter(conn, config.OutLog) } else { out = conn } return }
func (d *Decoder) readData(db *Database) error { masterKey, err := db.Credentials.buildMasterKey(db) if err != nil { return err } block, err := aes.NewCipher(masterKey) if err != nil { return err } in, err := ioutil.ReadAll(d.r) if err != nil { return err } mode := cipher.NewCBCDecrypter(block, db.Headers.EncryptionIV) decrypted := make([]byte, len(in)) mode.CryptBlocks(decrypted, in) startBytes := db.Headers.StreamStartBytes if !reflect.DeepEqual(decrypted[0:len(startBytes)], startBytes) { return errors.New("Database integrity check failed") } decrypted = decrypted[len(startBytes):] var xmlDecoder *xml.Decoder if db.Headers.CompressionFlags == GzipCompressionFlag { //Unzip if the header compression flag is 1 for gzip zippedBody, err := checkHashBlocks(decrypted) if err != nil { return err } b := bytes.NewBuffer(zippedBody) r, err := gzip.NewReader(b) if err != nil { return err } defer r.Close() xmlDecoder = xml.NewDecoder(r) } else { //Otherwise assume it not compressed xmlDecoder = xml.NewDecoder(bytes.NewReader(decrypted)) } db.Content = &DBContent{} err = xmlDecoder.Decode(db.Content) return err }
func Fuzz(data []byte) int { score := 0 for _, ctor := range []func() interface{}{ func() interface{} { return nil }, func() interface{} { return new(string) }, func() interface{} { return new([]string) }, func() interface{} { return new(X) }, func() interface{} { return new([]X) }, } { v0 := ctor() valid := false dec := xml.NewDecoder(bytes.NewReader(data)) if dec.Decode(v0) == nil { valid = true } v := ctor() dec1 := xml.NewDecoder(bytes.NewReader(data)) dec1.Strict = false dec1.AutoClose = xml.HTMLAutoClose dec1.Entity = xml.HTMLEntity if dec1.Decode(v) != nil { if valid { panic("non-strict mode is weaker than strict") } continue } score = 1 data1, err := xml.Marshal(v) if err != nil { panic(err) } v1 := ctor() dec2 := xml.NewDecoder(bytes.NewReader(data1)) dec2.Strict = false dec2.AutoClose = xml.HTMLAutoClose dec2.Entity = xml.HTMLEntity if err := dec2.Decode(v1); err != nil { panic(err) } if !fuzz.DeepEqual(v, v1) { fmt.Printf("v0: %#v\n", reflect.ValueOf(v).Elem().Interface()) fmt.Printf("v1: %#v\n", reflect.ValueOf(v1).Elem().Interface()) panic(fmt.Sprintf("not equal %T", v)) } } return score }
// GetGame gets the game information from the DB. func GetGame(req GGReq) (*GGResp, error) { u, err := url.Parse(GDBURL) u.Path = GGPath q := url.Values{} switch { case req.ID != "": q.Set("id", req.ID) case req.Name != "": q.Set("name", req.Name) if req.Platform != "" { q.Set("platform", req.Platform) } default: return nil, fmt.Errorf("must provide an ID or Name.") } u.RawQuery = q.Encode() resp, err := http.Get(u.String()) if err != nil { return nil, fmt.Errorf("getting game url:%s, error:%s", u, err) } defer resp.Body.Close() r := &GGResp{} decoder := xml.NewDecoder(resp.Body) if err := decoder.Decode(r); err != nil { return nil, err } if r.XMLName.Local == "Error" { return nil, fmt.Errorf("GetGame error: %s", r.err) } else { r.err = "" } return r, nil }
func (ec2 *EC2) query(params map[string]string, resp interface{}) error { params["Version"] = "2013-02-01" params["Timestamp"] = timeNow().In(time.UTC).Format(time.RFC3339) endpoint, err := url.Parse(ec2.Region.EC2Endpoint) if err != nil { return err } if endpoint.Path == "" { endpoint.Path = "/" } sign(ec2.Auth, "GET", endpoint.Path, params, endpoint.Host) endpoint.RawQuery = multimap(params).Encode() if debug { log.Printf("get { %v } -> {\n", endpoint.String()) } r, err := http.Get(endpoint.String()) if err != nil { return err } defer r.Body.Close() if debug { dump, _ := httputil.DumpResponse(r, true) log.Printf("response:\n") log.Printf("%v\n}\n", string(dump)) } if r.StatusCode != 200 { return buildError(r) } err = xml.NewDecoder(r.Body).Decode(resp) return err }
// GetGameList gets the game information from the DB. func GetGameList(req GGLReq) (*GGLResp, error) { u, err := url.Parse(GDBURL) u.Path = GGLPath q := url.Values{} if req.Name == "" { return nil, fmt.Errorf("must provide Name") } q.Set("name", req.Name) if req.Platform != "" { q.Set("platform", req.Platform) } if req.Genre != "" { q.Set("genre", req.Genre) } u.RawQuery = q.Encode() resp, err := http.Get(u.String()) if err != nil { return nil, fmt.Errorf("getting game list url:%s, error:%s", u, err) } defer resp.Body.Close() r := &GGLResp{} decoder := xml.NewDecoder(resp.Body) if err := decoder.Decode(r); err != nil { return nil, err } if r.XMLName.Local == "Error" { return nil, fmt.Errorf("GetGameList error: %s", r.err) } else { r.err = "" } return r, nil }
// Sends an S3 multipart upload initiation request. // See http://docs.amazonwebservices.com/AmazonS3/latest/dev/mpuoverview.html. // This initial request returns an UploadId that we use to identify // subsequent PUT requests. func newUploader(url string, h http.Header, c *Config) (u *uploader, err error) { u = new(uploader) u.s3 = *c.Service u.url = url u.keys = *c.Keys u.bufsz = minPartSize r, err := http.NewRequest("POST", url+"?uploads", nil) if err != nil { return nil, err } r.Header.Set("Date", time.Now().UTC().Format(http.TimeFormat)) for k := range h { for _, v := range h[k] { r.Header.Add(k, v) } } u.s3.Sign(r, u.keys) resp, err := http.DefaultClient.Do(r) if err != nil { return nil, err } defer resp.Body.Close() if resp.StatusCode != 200 { return nil, newRespError(resp) } err = xml.NewDecoder(resp.Body).Decode(u) if err != nil { return nil, err } u.ch = make(chan *part) for i := 0; i < concurrency; i++ { go u.worker() } return u, nil }