Example #1
1
func (c *Client) merchantUploadImageFromBytesReader(filename string, reader *bytes.Reader) (imageURL string, err error) {
	originalOffset, err := reader.Seek(0, 1)
	if err != nil {
		return
	}

	FormDataFileName := escapeQuotes(filename)
	ContentLength := int64(multipart_constPartLen + len(FormDataFileName) + reader.Len())

	hasRetry := false
RETRY:
	token, err := c.Token()
	if err != nil {
		return
	}
	url_ := merchantUploadImageURL(token, filename)

	if hasRetry {
		if _, err = reader.Seek(originalOffset, 0); err != nil {
			return
		}
	}
	mr := io.MultiReader(
		strings.NewReader(multipart_formDataFront),
		strings.NewReader(FormDataFileName),
		strings.NewReader(multipart_formDataMiddle),
		reader,
		strings.NewReader(multipart_formDataEnd),
	)

	httpReq, err := http.NewRequest("POST", url_, mr)
	if err != nil {
		return
	}
	httpReq.Header.Set("Content-Type", multipart_ContentType)
	httpReq.ContentLength = ContentLength

	httpResp, err := c.httpClient.Do(httpReq)
	if err != nil {
		return
	}
	defer httpResp.Body.Close()

	if httpResp.StatusCode != http.StatusOK {
		err = fmt.Errorf("http.Status: %s", httpResp.Status)
		return
	}

	var result struct {
		Error
		ImageURL string `json:"image_url"`
	}
	if err = json.NewDecoder(httpResp.Body).Decode(&result); err != nil {
		return
	}

	switch result.ErrCode {
	case errCodeOK:
		imageURL = result.ImageURL
		return

	case errCodeTimeout:
		if !hasRetry {
			hasRetry = true
			timeoutRetryWait()
			goto RETRY
		}
		fallthrough

	default:
		err = &result.Error
		return
	}
}
Example #2
0
// HandleLog is the default http log handler
func HandleLog(h HTTP, entries <-chan *log.Entry) {
	var e *log.Entry
	var b []byte
	var reader *bytes.Reader

	formatter := h.FormatFunc()(h)
	remoteHost := h.RemoteHost()
	httpClient := stdhttp.Client{}

	req, _ := stdhttp.NewRequest(h.Method(), remoteHost, nil)
	req.Header = h.Headers()

	for e = range entries {

		b = formatter(e)

		reader = bytes.NewReader(b)
		req.Body = ioutil.NopCloser(reader)
		req.ContentLength = int64(reader.Len())

		resp, err := httpClient.Do(req)
		if err != nil {
			log.Error("Could not post data to %s: %v\n", remoteHost, err)
			goto END
		}

		if resp.StatusCode < 200 || resp.StatusCode >= 299 {
			bt, _ := ioutil.ReadAll(resp.Body)
			log.Error("Received HTTP %d during POST request to %s body: %s\n", resp.StatusCode, remoteHost, string(bt))
		}

	END:
		e.Consumed()
	}
}
Example #3
0
func installZip(source *bytes.Reader, dest string) error {
	zr, err := zip.NewReader(source, int64(source.Len()))
	if err != nil {
		return err
	}

	for _, f := range zr.File {
		fileCopy, err := os.OpenFile(dest, installFlag, f.Mode())
		if err != nil {
			return err
		}
		defer fileCopy.Close()

		rc, err := f.Open()
		if err != nil {
			return err
		}
		defer rc.Close()

		_, err = io.Copy(fileCopy, rc)
		if err != nil {
			return err
		}
	}

	return nil
}
Example #4
0
func readTracks(reader *bytes.Reader, encodedDataSize int) ([]Track, error) {
	var tracks []Track

	position := encodedDataSize - reader.Len()

	for position < encodedDataSize {
		var id int32
		binary.Read(reader, binary.LittleEndian, &id)

		channelNameSize, _ := reader.ReadByte()
		channelBytes := make([]byte, channelNameSize)
		_, err := reader.Read(channelBytes)
		if err != nil {
			return []Track{}, errors.New("Could not read Track name with id " + string(id))
		}

		pattern := make([]uint32, 4)
		patternReadErr := binary.Read(reader, binary.LittleEndian, &pattern)
		if patternReadErr != nil {
			return []Track{}, errors.New("Could not read Track step with id " + string(id))
		}

		tracks = append(tracks, Track{
			id,
			string(channelBytes),
			pattern})

		position += int(21) + int(channelNameSize)
	}

	return tracks, nil
}
Example #5
0
func (k *KeenIoMetrics) AuthedRequest(method, path string, body *bytes.Reader) (resp *http.Response, err error) {
	path = fmt.Sprintf("https://api.keen.io/3.0/projects/%s%s", k.ProjectToken, path)
	req, err := http.NewRequest(method, path, body)
	if err != nil {
		return
	}

	req.Header.Add("Authorization", k.ApiKey)

	if body != nil {
		req.Header.Add("Content-Type", "application/json")
		req.ContentLength = int64(body.Len())
	}

	resp, err = k.HttpClient.Do(req)

	if err != nil {
		k.Error("Failed to send metric event to keen.io %v", err)
	} else {
		defer resp.Body.Close()
		if resp.StatusCode != 201 {
			bytes, _ := ioutil.ReadAll(resp.Body)
			k.Error("Got %v response from keen.io: %s", resp.StatusCode, bytes)
		}
	}

	return
}
Example #6
0
func (sitemap *SitemapPage) parseSitemapPageNoGzip(mem_seek *bytes.Reader) (byte_reader *bytes.Reader, err error) {
	// validate uncompressed size
	if mem_seek.Len() > max_sitemap_page_size {
		return mem_seek, max_sitemap_page_size_error
	}

	err = sitemap.determineIteratorFormat(mem_seek)
	return mem_seek, err
}
Example #7
0
func (self *Entity) Store(
	storageObj *data.Storage,
	objectObj *data.Object,
	input *bytes.Reader,
) error {
	ctx := self.Ctx()

	closer := ctx.LogMark("[Entity.Store]")
	defer closer()

	uri := strings.Join([]string{storageObj.Uri, objectObj.InternalName}, "/")
	cl := input.Len()

	ctx.Debugf("Going to store %d bytes in %s", cl, uri)

	req, err := http.NewRequest("PUT", uri, input)
	if err != nil {
		ctx.Debugf("Failed to create request: %s", err)
		return err
	}

	// XXX Need to check if this vanilla http client is ok
	client := &http.Client{}
	resp, err := client.Do(req)
	if err != nil {
		ctx.Debugf("Failed to send PUT request to %s (storage = %d): %s", uri, storageObj.Id, err)
		return err
	}

	if resp.StatusCode != 201 {
		err = errors.New(
			fmt.Sprintf(
				"Expected response 201 for PUT request, but did not get it: %s",
				resp.Status,
			),
		)
		ctx.Debugf("Failed to store PUT request to %s (storage = %d): %s", uri, storageObj.Id, err)
		return err
	}

	ctx.Debugf("Successfully stored object in %s", uri)

	err = self.Create(
		objectObj.Id,
		storageObj.Id,
	)

	if err != nil {
		return err
	}

	return nil
}
Example #8
0
func (p *Pattern) parseTracks(r *bytes.Reader) error {
	for r.Len() > 0 {
		t := &Track{}
		err := t.parse(r)
		if err != nil {
			fmt.Println("parse Track failed:", err)
			return err
		}
		p.Tracks = append(p.Tracks, *t)
	}

	return nil
}
Example #9
0
func (h *HTTPSender) buildBaseRequest(contextPath string, method string, headers map[string][]string, bodyReader *bytes.Reader) *http.Request {
	var req http.Request
	req.Method = h.method
	req.ProtoMajor = 1
	req.ProtoMinor = 1
	req.Close = false
	req.Header = h.headers
	req.URL = h.parsedContextPath
	req.URL.Host = h.hosts[h.currentHost]
	req.Body = ioutil.NopCloser(bodyReader)
	req.ContentLength = int64(bodyReader.Len())
	return &req
}
Example #10
0
// putBucketRequest wrapper creates a new putBucket request
func (a apiCore) putBucketRequest(bucket, acl, location string) (*request, error) {
	var r *request
	var err error
	op := &operation{
		HTTPServer: a.config.Endpoint,
		HTTPMethod: "PUT",
		HTTPPath:   separator + bucket,
	}
	var createBucketConfigBuffer *bytes.Reader
	// If location is set use it and create proper bucket configuration
	switch {
	case location != "":
		createBucketConfig := new(createBucketConfiguration)
		createBucketConfig.Location = location
		var createBucketConfigBytes []byte
		switch {
		case a.config.AcceptType == "application/xml":
			createBucketConfigBytes, err = xml.Marshal(createBucketConfig)
		case a.config.AcceptType == "application/json":
			createBucketConfigBytes, err = json.Marshal(createBucketConfig)
		default:
			createBucketConfigBytes, err = xml.Marshal(createBucketConfig)
		}
		if err != nil {
			return nil, err
		}
		createBucketConfigBuffer = bytes.NewReader(createBucketConfigBytes)
	}
	switch {
	case createBucketConfigBuffer == nil:
		r, err = newRequest(op, a.config, nil)
		if err != nil {
			return nil, err
		}
	default:
		r, err = newRequest(op, a.config, createBucketConfigBuffer)
		if err != nil {
			return nil, err
		}
		r.req.ContentLength = int64(createBucketConfigBuffer.Len())
	}
	// by default bucket is private
	switch {
	case acl != "":
		r.Set("x-amz-acl", acl)
	default:
		r.Set("x-amz-acl", "private")
	}

	return r, nil
}
Example #11
0
func (table_entry *EWF_Table_Section_Entry) Parse(buf *bytes.Reader) {
	var b *bytes.Reader

	val := make([]byte, int64(buf.Len()))

	buf.Read(val)
	//parse struct attributes
	table_entry.IsCompressed = val[3] << 1 & 1
	val[3] &= 0x7F //exlude MSB

	b = bytes.NewReader(val)

	parseutil.Parse(b, &table_entry.ChunkDataOffset)
}
Example #12
0
func readUnsubscribePayload(r *bytes.Reader) (s UnsubscribePacket, err error) {
	if r.Len() == 0 {
		err = errors.New("cannot unsubscribe from zero topics")
		return
	}
	var unsub Unsubscription
	for r.Len() > 0 {
		unsub, err = readUnsubscription(r)
		if err != nil {
			return
		}
		s.Unsubscriptions = append(s.Unsubscriptions, unsub)
	}
	return
}
Example #13
0
File: mx.go Project: h8liu/d8
func unpackLabels(in *bytes.Reader, n uint16, p []byte) ([]string, error) {
	if n == 0 {
		return nil, errors.New("zero labels len")
	}

	was := in.Len()
	d, e := domain.UnpackLabels(in, p)
	now := in.Len()
	if was-now != int(n) {
		return nil, fmt.Errorf("domain length expect %d, actual %d",
			n, was-now)
	}

	return d, e
}
Example #14
0
func readSubscribePayload(r *bytes.Reader) (s SubscribePacket, err error) {
	s.MessageID, err = readMessageID(r)
	if err != nil {
		return
	}
	if r.Len() == 0 {
		err = errors.New("zero subscriptions")
		return
	}
	var sub Subscription
	for r.Len() > 0 {
		sub, err = readSubscription(r)
		if err != nil {
			return
		}
		s.Subscriptions = append(s.Subscriptions, sub)
	}
	return
}
Example #15
0
func readSubAckPayload(r *bytes.Reader) (p SubAckPacket, err error) {
	p.MessageID, err = readMessageID(r)
	if err != nil {
		return
	}
	qos_size := r.Len()
	if qos_size == 0 {
		err = errors.New("Missing grantedqos")
		return
	}
	p.GrantedQoS = make([]QoSLevel, qos_size)
	for i := range p.GrantedQoS {
		p.GrantedQoS[i], err = readQoS(r)
		if err != nil {
			return
		}
	}
	return
}
Example #16
0
File: rdata.go Project: h8liu/d8
func unpack(t, c uint16, in *bytes.Reader, p []byte) (Rdata, error) {
	n := uint16(in.Len())
	if c == IN {
		switch t {
		case A:
			return UnpackIPv4(in, n)
		case NS, CNAME:
			return UnpackDomain(in, n, p)
		case AAAA:
			return UnpackIPv6(in, n)
		case TXT:
			return UnpackString(in, n)
		case MX:
			return UnpackMailEx(in, n, p)
		case SOA:
			return UnpackSrcOfAuth(in, n, p)
		}
	}
	return UnpackBytes(in, n)
}
Example #17
0
func (ewf_table_section *EWF_Table_Section) Parse(buf *bytes.Reader) {

	defer parseutil.TimeTrack(time.Now(), "Parsing")
	val := make([]byte, int64(buf.Len()))

	buf.Read(val)

	ewf_table_section.table_header.Parse(bytes.NewReader(val[0:24]))
	ewf_table_section.table_footer.Parse(bytes.NewReader(val[len(val)-4 : len(val)]))
	val = val[24 : len(val)-4]
	k := 0
	ewf_table_section.Table_entries = make([]EWF_Table_Section_Entry, ewf_table_section.table_header.nofEntries)
	for i := uint32(0); i < ewf_table_section.table_header.nofEntries; i += 1 {

		ewf_table_section.Table_entries[i].Parse(bytes.NewReader(val[0+k : 4+k]))
		//  fmt.Println("EFW in by",i,
		//       ewf_table_section.table_entries[i].IsCompressed,ewf_table_section.table_entries[i].ChunkDataOffset)
		k += 4

	}

}
Example #18
0
File: soa.go Project: h8liu/d8
func UnpackSrcOfAuth(in *bytes.Reader, n uint16, p []byte) (*SrcOfAuth, error) {
	if n <= 22 {
		return nil, fmt.Errorf("soa with %d bytes", n)
	}

	ret := new(SrcOfAuth)
	was := in.Len()
	labels, e := domain.UnpackLabels(in, p)
	if e != nil {
		return nil, e
	}
	ret.Mname = labels

	labels, e = domain.UnpackLabels(in, p)
	if e != nil {
		return nil, e
	}
	ret.Rname = labels

	now := in.Len()
	if was-now+20 != int(n) {
		return nil, errors.New("invalid soa field length")
	}

	buf := make([]byte, 20)
	_, e = in.Read(buf)
	if e != nil {
		return nil, e
	}
	ret.Serial = enc.Uint32(buf[0:4])
	ret.Refresh = enc.Uint32(buf[4:8])
	ret.Retry = enc.Uint32(buf[8:12])
	ret.Expire = enc.Uint32(buf[12:16])
	ret.Minimum = enc.Uint32(buf[16:20])

	return ret, nil
}
Example #19
0
// Read variable integer in big endian
func ReadVarint(reader *bytes.Reader) (ret uint64) {
	if reader.Len() == 8 {
		var num uint64
		binary.Read(reader, binary.BigEndian, &num)
		ret = uint64(num)
	} else if reader.Len() == 4 {
		var num uint32
		binary.Read(reader, binary.BigEndian, &num)
		ret = uint64(num)
	} else if reader.Len() == 2 {
		var num uint16
		binary.Read(reader, binary.BigEndian, &num)
		ret = uint64(num)
	} else {
		var num uint8
		binary.Read(reader, binary.BigEndian, &num)
		ret = uint64(num)
	}

	return ret
}
Example #20
0
File: wav.go Project: gonutz/mixer
func (wav *Wave) parse(r *bytes.Reader, formatWasRead bool) error {
	if r.Len() == 0 {
		return nil
	}

	var header chunkHeader
	if err := binary.Read(r, endiannes, &header); err != nil {
		return loadErr("unable to read chunk header", err)
	}

	if header.ChunkID == formatChunkID {
		if formatWasRead {
			return errors.New("load WAV: two format chunks detected")
		}

		var chunk formatChunkExtended
		if header.ChunkSize == 16 {
			if err := binary.Read(r, endiannes, &(chunk.formatChunkBase)); err != nil {
				return loadErr("reading format chunk", err)
			}
		} else if header.ChunkSize == 18 {
			err := binary.Read(r, endiannes, &(chunk.formatChunkWithExtension))
			if err != nil {
				return loadErr("reading format chunk", err)
			}
		} else if header.ChunkSize == 40 {
			if err := binary.Read(r, endiannes, &chunk); err != nil {
				return loadErr("reading format chunk", err)
			}
		} else {
			return fmt.Errorf("load WAV: illegal format chunk header size: %v",
				header.ChunkSize)
		}

		if chunk.FormatTag != pcmFormat {
			return fmt.Errorf(
				"load WAV: unsupported format: %v (only PCM is supported)",
				chunk.FormatTag)
		}

		wav.ChannelCount = int(chunk.Channels)
		wav.SamplesPerSecond = int(chunk.SamplesPerSec)
		wav.BitsPerSample = int(chunk.BitsPerSample)
		formatWasRead = true
	} else if header.ChunkID == dataChunkID {
		data := make([]byte, header.ChunkSize)
		if _, err := io.ReadFull(r, data); err != nil {
			return err
		}

		if len(wav.Data) > 0 {
			return errors.New("load WAV: multiple data chunks found")
		}
		if !formatWasRead {
			return errors.New("load WAV: found data chunk before format chunk")
		}
		wav.Data = data

		if header.ChunkSize%2 == 1 {
			// there is one byte padding if the chunk size is odd
			if _, err := r.ReadByte(); err != nil {
				return loadErr("reading data chunk padding", err)
			}
		}
	} else {
		// skip unknown chunks
		io.CopyN(ioutil.Discard, r, int64(header.ChunkSize))
	}

	if r.Len() == 0 {
		if !formatWasRead {
			return errors.New("load WAV: file does not contain format information")
		}
		return nil
	}

	return wav.parse(r, formatWasRead)
}
Example #21
0
func (c *Conn) readPacket() (Packet, error) {
	// Length prefix
	size, err := ReadVarInt(c.r)
	if err != nil {
		return nil, err
	}
	if size < 0 {
		return nil, errNegativeLength
	}
	buf := make([]byte, size)
	if _, err := io.ReadFull(c.r, buf); err != nil {
		return nil, err
	}

	var r *bytes.Reader
	r = bytes.NewReader(buf)

	// If compression is enabled then we may need to decompress the packet
	if c.compressionThreshold >= 0 {
		// With compression enabled an extra length prefix is added
		// which is the length of the packet when uncompressed.
		uncompSize, err := ReadVarInt(r)
		if err != nil {
			return nil, err
		}
		// A uncompressed size of 0 means the packet wasn't compressed
		// and when can continue normally.
		if uncompSize != 0 {
			// Reuse the old reader to save on allocations
			if c.zlibReader == nil {
				c.zlibReader, err = zlib.NewReader(r)
				if err != nil {
					return nil, err
				}
			} else {
				err = c.zlibReader.(zlib.Resetter).Reset(r, nil)
				if err != nil {
					return nil, err
				}
			}

			// Read the whole packet at once instead of in tiny steps
			data := make([]byte, uncompSize)
			_, err := io.ReadFull(c.zlibReader, data)
			if err != nil {
				return nil, err
			}
			r = bytes.NewReader(data)
		}
	}

	// Packet ID
	id, err := ReadVarInt(r)
	if err != nil {
		return nil, err
	}
	// Direction is swapped as this is coming from the other way
	packets := packetCreator[c.State][(c.direction+1)&1]
	if id < 0 || int(id) >= len(packets) || packets[id] == nil {
		return nil, fmt.Errorf("Unknown packet %s:%02X", c.State, id)
	}
	packet := packets[id]()
	if err := packet.read(r); err != nil {
		return packet, fmt.Errorf("packet(%s:%02X): %s", c.State, id, err)
	}
	// If we haven't fully read the whole buffer then something went wrong.
	// Mostly likely our packet definitions are out of date or incorrect
	if r.Len() > 0 {
		return packet, fmt.Errorf("Didn't finish reading packet %s:%02X, have %d bytes left", c.State, id, r.Len())
	}
	if c.Logger != nil {
		c.Logger(true, packet)
	}
	return packet, nil
}
Example #22
0
func readRemainingBytes(r *bytes.Reader) (buf []byte, err error) {
	buf, err = readBytes(r.Len(), r)
	return
}
Example #23
0
func isValidReader(reader *bytes.Reader) {
	if reader == nil || reader.Len() == 0 {
		logger.Fatal("Deserialize Error! Buffer Is Empty")
	}
}
Example #24
0
// Recv returns the next packet parsed out of the stream.
func (p *Parser) Recv() (Packet, error) {
	p.conn.SetReadDeadline(time.Now().Add(p.timeout))

	length, err := ReadVarint(p.r)
	if err != nil {
		return nil, err
	}

	if length < 0 {
		return nil, ErrNegativeLength
	}

	b := make([]byte, length)
	if _, err := io.ReadFull(p.r, b); err != nil {
		return nil, err
	}

	var r *bytes.Reader
	r = bytes.NewReader(b)

	// If compression is enabled, we need to know how much data to expect first.
	if p.compressionThreshold >= 0 {
		// newSize is the decompressed size of the packet.
		newSize, err := ReadVarint(r)
		if err != nil {
			return nil, err
		}

		/*
			// Technically, this is meant to disconnect you, but we can just
			// ignore this case. Most parsers seem to.
			if newSize < p.compressionThreshold {
				return nil, ErrNotCompressed
			}
		*/

		// If newSize == 0, it's not compressed so we can just carry on anyway.
		if newSize != 0 {
			if p.zlibReader == nil {
				// If we don't already have a zlib reader, set one up.
				p.zlibReader, err = zlib.NewReader(r)
				if err != nil {
					return nil, err
				}
			} else {
				// If we do, reset with the current packet.
				err = p.zlibReader.(zlib.Resetter).Reset(r, nil)
				if err != nil {
					return nil, err
				}
			}

			data := make([]byte, newSize)
			_, err := io.ReadFull(p.zlibReader, data)
			if err != nil {
				return nil, err
			}
			r = bytes.NewReader(data)
		}
	}

	id, err := ReadVarint(r)
	if err != nil {
		return nil, err
	}

	// f() returns an empty Packet, that we'll decode into.
	f, ok := Packets[p.State][p.Direction.Flip()][byte(id)]
	if !ok {
		//fmt.Errorf("kyubu: unknown packet %s:%#.2x", p.State, id)
		return nil, ErrUnknownPacket
	}

	packet := f()

	if err := packet.Decode(r); err != nil {
		return nil, err
	}

	// If there are bytes left over, the decoding step missed something.
	if r.Len() > 0 {
		//fmt.Errorf("kyubu: Lost sync on packet %s:%#.2x, %d bytes left", p.State, id, r.Len())
		return nil, ErrLostSync
	}

	return packet, nil
}
Example #25
0
func (ewf_h2_section *EWF_Header2_Section) Parse(buf *bytes.Reader) {
	//0x09 tab 0x0a new line delimiter
	//function to parse header2 section attributes
	//to do take into account endianess
	val := make([]byte, buf.Len())
	buf.Read(val)
	val = parseutil.Decompress(val)

	defer parseutil.TimeTrack(time.Now(), "Parsing")
	line_del, _ := hex.DecodeString("0a")
	tab_del, err := hex.DecodeString("09")
	if err != nil {
		log.Fatal(err)
	}
	var b *bytes.Reader

	for line_number, line := range bytes.Split(val, line_del) {
		for id_num, attr := range bytes.Split(line, tab_del) {
			b = bytes.NewReader(attr)
			if line_number == 0 {
				parseutil.Parse(b, &ewf_h2_section.BOM)
				parseutil.Parse(b, &ewf_h2_section.NofCategories)

			} else if line_number == 1 {
				parseutil.Parse(b, &ewf_h2_section.CategoryName)
			} else if line_number == 2 {

			} else if line_number == 3 {
				if id_num == EWF_HEADER_VALUES_INDEX_DESCRIPTION {
					ewf_h2_section.a = string(attr)
					fmt.Println("TIME", ewf_h2_section.a)
				} else if id_num == EWF_HEADER_VALUES_INDEX_CASE_NUMBER {
					ewf_h2_section.c = string(attr)

				} else if id_num == EWF_HEADER_VALUES_INDEX_EXAMINER_NAME {
					ewf_h2_section.n = string(attr)
				} else if id_num == EWF_HEADER_VALUES_INDEX_EVIDENCE_NUMBER {
					ewf_h2_section.e = string(attr)
				} else if id_num == EWF_HEADER_VALUES_INDEX_NOTES {
					ewf_h2_section.t = string(attr)
				} else if id_num == EWF_HEADER_VALUES_INDEX_ACQUIRY_SOFTWARE_VERSION {
					ewf_h2_section.av = string(attr)
				} else if id_num == EWF_HEADER_VALUES_INDEX_ACQUIRY_OPERATING_SYSTEM {
					ewf_h2_section.ov = string(attr)
				} else if id_num == EWF_HEADER_VALUES_INDEX_ACQUIRY_DATE {
					ewf_h2_section.m = parseutil.SetTime(attr)

				} else if id_num == EWF_HEADER_VALUES_INDEX_SYSTEM_DATE {
					ewf_h2_section.u = parseutil.SetTime(attr)

				} else if id_num == EWF_HEADER_VALUES_INDEX_PASSWORD {
					ewf_h2_section.p = string(attr)
				} else if id_num == EWF_HEADER_VALUES_INDEX_PROCESS_IDENTIFIER {
					ewf_h2_section.pid = string(attr)

				}

			}
		}
	}

}