hunk.code_window:             image = (
                   <img
                       className='attachment__image'
                       crossOrigin='anonymous'
                       src={data.image_url}
                   />
               );
           }
  
hunk.labels: keep keep keep replace keep keep keep keep keep
hunk.file_path: webapp/components/post_view/components/post_attachment.jsx
hunk.type: replace
file: // Copyright 2016 The Go Authors. All rights reserved.
  // Use of this source code is governed by a BSD-style
  // license that can be found in the LICENSE file.
  
  // +build darwin dragonfly freebsd netbsd openbsd
  
  package route
  
  import "runtime"
  
  // An Addr represents an address associated with packet routing.
  type Addr interface {
  	// Family returns an address family.
  	Family() int
  }
  
  // A LinkAddr represents a link-layer address.
  type LinkAddr struct {
  	Index int    // interface index when attached
  	Name  string // interface name when attached
  	Addr  []byte // link-layer address when attached
  }
  
  // Family implements the Family method of Addr interface.
  func (a *LinkAddr) Family() int { return sysAF_LINK }
  
  func (a *LinkAddr) lenAndSpace() (int, int) {
  	l := 8 + len(a.Name) + len(a.Addr)
  	return l, roundup(l)
  }
  
  func (a *LinkAddr) marshal(b []byte) (int, error) {
  	l, ll := a.lenAndSpace()
  	if len(b) < ll {
  		return 0, errShortBuffer
  	}
  	nlen, alen := len(a.Name), len(a.Addr)
  	if nlen > 255 || alen > 255 {
  		return 0, errInvalidAddr
  	}
  	b[0] = byte(l)
  	b[1] = sysAF_LINK
  	if a.Index > 0 {
  		nativeEndian.PutUint16(b[2:4], uint16(a.Index))
  	}
  	data := b[8:]
  	if nlen > 0 {
  		b[5] = byte(nlen)
  		copy(data[:nlen], a.Addr)
  		data = data[nlen:]
  	}
  	if alen > 0 {
  		b[6] = byte(alen)
  		copy(data[:alen], a.Name)
  		data = data[alen:]
  	}
  	return ll, nil
  }
  
  func parseLinkAddr(b []byte) (Addr, error) {
  	if len(b) < 8 {
  		return nil, errInvalidAddr
  	}
  	_, a, err := parseKernelLinkAddr(sysAF_LINK, b[4:])
  	if err != nil {
  		return nil, err
  	}
  	a.(*LinkAddr).Index = int(nativeEndian.Uint16(b[2:4]))
  	return a, nil
  }
  
  // parseKernelLinkAddr parses b as a link-layer address in
  // conventional BSD kernel form.
  func parseKernelLinkAddr(_ int, b []byte) (int, Addr, error) {
  	// The encoding looks like the following:
  	// +----------------------------+
  	// | Type             (1 octet) |
  	// +----------------------------+
  	// | Name length      (1 octet) |
  	// +----------------------------+
  	// | Address length   (1 octet) |
  	// +----------------------------+
  	// | Selector length  (1 octet) |
  	// +----------------------------+
  	// | Data            (variable) |
  	// +----------------------------+
  	//
  	// On some platforms, all-bit-one of length field means "don't
  	// care".
  	nlen, alen, slen := int(b[1]), int(b[2]), int(b[3])
  	if nlen == 0xff {
  		nlen = 0
  	}
  	if alen == 0xff {
  		alen = 0
  	}
  	if slen == 0xff {
  		slen = 0
  	}
  	l := 4 + nlen + alen + slen
  	if len(b) < l {
  		return 0, nil, errInvalidAddr
  	}
  	data := b[4:]
  	var name string
  	var addr []byte
  	if nlen > 0 {
  		name = string(data[:nlen])
  		data = data[nlen:]
  	}
  	if alen > 0 {
  		addr = data[:alen]
  		data = data[alen:]
  	}
  	return l, &LinkAddr{Name: name, Addr: addr}, nil
  }
  
  // An Inet4Addr represents an internet address for IPv4.
  type Inet4Addr struct {
  	IP [4]byte // IP address
  }
  
  // Family implements the Family method of Addr interface.
  func (a *Inet4Addr) Family() int { return sysAF_INET }
  
  func (a *Inet4Addr) lenAndSpace() (int, int) {
  	return sizeofSockaddrInet, roundup(sizeofSockaddrInet)
  }
  
  func (a *Inet4Addr) marshal(b []byte) (int, error) {
  	l, ll := a.lenAndSpace()
  	if len(b) < ll {
  		return 0, errShortBuffer
  	}
  	b[0] = byte(l)
  	b[1] = sysAF_INET
  	copy(b[4:8], a.IP[:])
  	return ll, nil
  }
  
  // An Inet6Addr represents an internet address for IPv6.
  type Inet6Addr struct {
  	IP     [16]byte // IP address
  	ZoneID int      // zone identifier
  }
  
  // Family implements the Family method of Addr interface.
  func (a *Inet6Addr) Family() int { return sysAF_INET6 }
  
  func (a *Inet6Addr) lenAndSpace() (int, int) {
  	return sizeofSockaddrInet6, roundup(sizeofSockaddrInet6)
  }
  
  func (a *Inet6Addr) marshal(b []byte) (int, error) {
  	l, ll := a.lenAndSpace()
  	if len(b) < ll {
  		return 0, errShortBuffer
  	}
  	b[0] = byte(l)
  	b[1] = sysAF_INET6
  	copy(b[8:24], a.IP[:])
  	if a.ZoneID > 0 {
  		nativeEndian.PutUint32(b[24:28], uint32(a.ZoneID))
  	}
  	return ll, nil
  }
  
  // parseInetAddr parses b as an internet address for IPv4 or IPv6.
  func parseInetAddr(af int, b []byte) (Addr, error) {
  	switch af {
  	case sysAF_INET:
  		if len(b) < sizeofSockaddrInet {
  			return nil, errInvalidAddr
  		}
  		a := &Inet4Addr{}
  		copy(a.IP[:], b[4:8])
  		return a, nil
  	case sysAF_INET6:
  		if len(b) < sizeofSockaddrInet6 {
  			return nil, errInvalidAddr
  		}
  		a := &Inet6Addr{ZoneID: int(nativeEndian.Uint32(b[24:28]))}
  		copy(a.IP[:], b[8:24])
  		if a.IP[0] == 0xfe && a.IP[1]&0xc0 == 0x80 || a.IP[0] == 0xff && (a.IP[1]&0x0f == 0x01 || a.IP[1]&0x0f == 0x02) {
  			// KAME based IPv6 protocol stack usually
  			// embeds the interface index in the
  			// interface-local or link-local address as
  			// the kernel-internal form.
  			id := int(bigEndian.Uint16(a.IP[2:4]))
  			if id != 0 {
  				a.ZoneID = id
  				a.IP[2], a.IP[3] = 0, 0
  			}
  		}
  		return a, nil
  	default:
  		return nil, errInvalidAddr
  	}
  }
  
  // parseKernelInetAddr parses b as an internet address in conventional
  // BSD kernel form.
  func parseKernelInetAddr(af int, b []byte) (int, Addr, error) {
  	// The encoding looks similar to the NLRI encoding.
  	// +----------------------------+
  	// | Length           (1 octet) |
  	// +----------------------------+
  	// | Address prefix  (variable) |
  	// +----------------------------+
  	//
  	// The differences between the kernel form and the NLRI
  	// encoding are:
  	//
  	// - The length field of the kernel form indicates the prefix
  	//   length in bytes, not in bits
  	//
  	// - In the kernel form, zero value of the length field
  	//   doesn't mean 0.0.0.0/0 or ::/0
  	//
  	// - The kernel form appends leading bytes to the prefix field
  	//   to make the <length, prefix> tuple to be conformed with
  	//   the routing message boundary
  	l := int(b[0])
  	if runtime.GOOS == "darwin" {
  		// On Darwn, an address in the kernel form is also
  		// used as a message filler.
  		if l == 0 || len(b) > roundup(l) {
  			l = roundup(l)
  		}
  	} else {
  		l = roundup(l)
  	}
  	if len(b) < l {
  		return 0, nil, errInvalidAddr
  	}
  	// Don't reorder case expressions.
  	// The case expressions for IPv6 must come first.
  	const (
  		off4 = 4 // offset of in_addr
  		off6 = 8 // offset of in6_addr
  	)
  	switch {
  	case b[0] == sizeofSockaddrInet6:
  		a := &Inet6Addr{}
  		copy(a.IP[:], b[off6:off6+16])
  		return int(b[0]), a, nil
  	case af == sysAF_INET6:
  		a := &Inet6Addr{}
  		if l-1 < off6 {
  			copy(a.IP[:], b[1:l])
  		} else {
  			copy(a.IP[:], b[l-off6:l])
  		}
  		return int(b[0]), a, nil
  	case b[0] == sizeofSockaddrInet:
  		a := &Inet4Addr{}
  		copy(a.IP[:], b[off4:off4+4])
  		return int(b[0]), a, nil
  	default: // an old fashion, AF_UNSPEC or unknown means AF_INET
  		a := &Inet4Addr{}
  		if l-1 < off4 {
  			copy(a.IP[:], b[1:l])
  		} else {
  			copy(a.IP[:], b[l-off4:l])
  		}
  		return int(b[0]), a, nil
  	}
  }
  
  // A DefaultAddr represents an address of various operating
  // system-specific features.
  type DefaultAddr struct {
  	af  int
  	Raw []byte // raw format of address
  }
  
  // Family implements the Family method of Addr interface.
  func (a *DefaultAddr) Family() int { return a.af }
  
  func (a *DefaultAddr) lenAndSpace() (int, int) {
  	l := len(a.Raw)
  	return l, roundup(l)
  }
  
  func (a *DefaultAddr) marshal(b []byte) (int, error) {
  	l, ll := a.lenAndSpace()
  	if len(b) < ll {
  		return 0, errShortBuffer
  	}
  	if l > 255 {
  		return 0, errInvalidAddr
  	}
  	b[1] = byte(l)
  	copy(b[:l], a.Raw)
  	return ll, nil
  }
  
  func parseDefaultAddr(b []byte) (Addr, error) {
  	if len(b) < 2 || len(b) < int(b[0]) {
  		return nil, errInvalidAddr
  	}
  	a := &DefaultAddr{af: int(b[1]), Raw: b[:b[0]]}
  	return a, nil
  }
  
  func addrsSpace(as []Addr) int {
  	var l int
  	for _, a := range as {
  		switch a := a.(type) {
  		case *LinkAddr:
  			_, ll := a.lenAndSpace()
  			l += ll
  		case *Inet4Addr:
  			_, ll := a.lenAndSpace()
  			l += ll
  		case *Inet6Addr:
  			_, ll := a.lenAndSpace()
  			l += ll
  		case *DefaultAddr:
  			_, ll := a.lenAndSpace()
  			l += ll
  		}
  	}
  	return l
  }
  
  // marshalAddrs marshals as and returns a bitmap indicating which
  // address is stored in b.
  func marshalAddrs(b []byte, as []Addr) (uint, error) {
  	var attrs uint
  	for i, a := range as {
  		switch a := a.(type) {
  		case *LinkAddr:
  			l, err := a.marshal(b)
  			if err != nil {
  				return 0, err
  			}
  			b = b[l:]
  			attrs |= 1 << uint(i)
  		case *Inet4Addr:
  			l, err := a.marshal(b)
  			if err != nil {
  				return 0, err
  			}
  			b = b[l:]
  			attrs |= 1 << uint(i)
  		case *Inet6Addr:
  			l, err := a.marshal(b)
  			if err != nil {
  				return 0, err
  			}
  			b = b[l:]
  			attrs |= 1 << uint(i)
  		case *DefaultAddr:
  			l, err := a.marshal(b)
  			if err != nil {
  				return 0, err
  			}
  			b = b[l:]
  			attrs |= 1 << uint(i)
  		}
  	}
  	return attrs, nil
  }
  
  func parseAddrs(attrs uint, fn func(int, []byte) (int, Addr, error), b []byte) ([]Addr, error) {
  	var as [sysRTAX_MAX]Addr
  	af := int(sysAF_UNSPEC)
  	for i := uint(0); i < sysRTAX_MAX && len(b) >= roundup(0); i++ {
  		if attrs&(1<<i) == 0 {
  			continue
  		}
  		if i <= sysRTAX_BRD {
  			switch b[1] {
  			case sysAF_LINK:
  				a, err := parseLinkAddr(b)
  				if err != nil {
  					return nil, err
  				}
  				as[i] = a
  				l := roundup(int(b[0]))
  				if len(b) < l {
  					return nil, errMessageTooShort
  				}
  				b = b[l:]
  			case sysAF_INET, sysAF_INET6:
  				af = int(b[1])
  				a, err := parseInetAddr(af, b)
  				if err != nil {
  					return nil, err
  				}
  				as[i] = a
  				l := roundup(int(b[0]))
  				if len(b) < l {
  					return nil, errMessageTooShort
  				}
  				b = b[l:]
  			default:
  				l, a, err := fn(af, b)
  				if err != nil {
  					return nil, err
  				}
  				as[i] = a
  				ll := roundup(l)
  				if len(b) < ll {
  					b = b[l:]
  				} else {
  					b = b[ll:]
  				}
  			}
  		} else {
  			a, err := parseDefaultAddr(b)
  			if err != nil {
  				return nil, err
  			}
  			as[i] = a
  			l := roundup(int(b[0]))
  			if len(b) < l {
  				return nil, errMessageTooShort
  			}
  			b = b[l:]
  		}
  	}
  	return as[:], nil
  }
  