func (v *KCPConfig) Build() (*serial.TypedMessage, error) { config := new(kcp.Config) if v.Mtu != nil { mtu := *v.Mtu if mtu < 576 || mtu > 1460 { return nil, errors.Format("KCP|Config: Invalid MTU size: %d", mtu) } config.Mtu = &kcp.MTU{Value: mtu} } if v.Tti != nil { tti := *v.Tti if tti < 10 || tti > 100 { return nil, errors.Format("KCP|Config: Invalid TTI: %d", tti) } config.Tti = &kcp.TTI{Value: tti} } if v.UpCap != nil { config.UplinkCapacity = &kcp.UplinkCapacity{Value: *v.UpCap} } if v.DownCap != nil { config.DownlinkCapacity = &kcp.DownlinkCapacity{Value: *v.DownCap} } if v.Congestion != nil { config.Congestion = *v.Congestion } if v.ReadBufferSize != nil { size := *v.ReadBufferSize if size > 0 { config.ReadBuffer = &kcp.ReadBuffer{Size: size * 1024 * 1024} } else { config.ReadBuffer = &kcp.ReadBuffer{Size: 512 * 1024} } } if v.WriteBufferSize != nil { size := *v.WriteBufferSize if size > 0 { config.WriteBuffer = &kcp.WriteBuffer{Size: size * 1024 * 1024} } else { config.WriteBuffer = &kcp.WriteBuffer{Size: 512 * 1024} } } if len(v.HeaderConfig) > 0 { headerConfig, _, err := kcpHeaderLoader.Load(v.HeaderConfig) if err != nil { return nil, errors.Base(err).Message("Invalid mKCP header config.") } ts, err := headerConfig.(Buildable).Build() if err != nil { return nil, errors.Base(err).Message("Invalid mKCP header config.") } config.HeaderConfig = ts } return serial.ToTypedMessage(config), nil }
func main() { resp, err := http.Get(apnicFile) if err != nil { panic(err) } if resp.StatusCode != 200 { panic(errors.Format("Unexpected status %d", resp.StatusCode)) } defer resp.Body.Close() scanner := bufio.NewScanner(resp.Body) ips := &geoip.CountryIPRange{ Ips: make([]*router.CIDR, 0, 8192), } for scanner.Scan() { line := scanner.Text() line = strings.TrimSpace(line) parts := strings.Split(line, "|") if len(parts) < 5 { continue } if strings.ToLower(parts[1]) != "cn" || strings.ToLower(parts[2]) != "ipv4" { continue } ip := parts[3] count, err := strconv.Atoi(parts[4]) if err != nil { continue } mask := uint32(math.Floor(math.Log2(float64(count)) + 0.5)) ipBytes := net.ParseIP(ip) if len(ipBytes) == 0 { panic("Invalid IP " + ip) } ips.Ips = append(ips.Ips, &router.CIDR{ Ip: []byte(ipBytes)[12:16], Prefix: 32 - mask, }) } ipbytes, err := proto.Marshal(ips) if err != nil { log.Fatalf("Failed to marshal country IPs: %v", err) } file, err := os.OpenFile("geoip_data.go", os.O_WRONLY|os.O_TRUNC|os.O_CREATE, 0644) if err != nil { log.Fatalf("Failed to generate geoip_data.go: %v", err) } defer file.Close() fmt.Fprintln(file, "package geoip") fmt.Fprintln(file, "var ChinaIPs = "+formatArray(ipbytes)) }
func ReadRequest(reader io.Reader) (request *Socks5Request, err error) { buffer := buf.NewLocal(512) defer buffer.Release() err = buffer.AppendSupplier(buf.ReadFullFrom(reader, 4)) if err != nil { return } request = &Socks5Request{ Version: buffer.Byte(0), Command: buffer.Byte(1), // buffer[2] is a reserved field AddrType: buffer.Byte(3), } switch request.AddrType { case AddrTypeIPv4: _, err = io.ReadFull(reader, request.IPv4[:]) if err != nil { return } case AddrTypeDomain: buffer.Clear() err = buffer.AppendSupplier(buf.ReadFullFrom(reader, 1)) if err != nil { return } domainLength := int(buffer.Byte(0)) err = buffer.AppendSupplier(buf.ReadFullFrom(reader, domainLength)) if err != nil { return } request.Domain = string(buffer.BytesFrom(-domainLength)) case AddrTypeIPv6: _, err = io.ReadFull(reader, request.IPv6[:]) if err != nil { return } default: err = errors.Format("Socks: Unexpected address type %d", request.AddrType) return } err = buffer.AppendSupplier(buf.ReadFullFrom(reader, 2)) if err != nil { return } request.Port = v2net.PortFromBytes(buffer.BytesFrom(-2)) return }
func ReadUDPRequest(packet []byte) (*Socks5UDPRequest, error) { if len(packet) < 5 { return nil, errors.New("Socks|UDP: Insufficient length of packet.") } request := new(Socks5UDPRequest) // packet[0] and packet[1] are reserved request.Fragment = packet[2] addrType := packet[3] var dataBegin int switch addrType { case AddrTypeIPv4: if len(packet) < 10 { return nil, errors.New("Socks|UDP: Insufficient length of packet.") } ip := packet[4:8] request.Port = v2net.PortFromBytes(packet[8:10]) request.Address = v2net.IPAddress(ip) dataBegin = 10 case AddrTypeIPv6: if len(packet) < 22 { return nil, errors.New("Socks|UDP: Insufficient length of packet.") } ip := packet[4:20] request.Port = v2net.PortFromBytes(packet[20:22]) request.Address = v2net.IPAddress(ip) dataBegin = 22 case AddrTypeDomain: domainLength := int(packet[4]) if len(packet) < 5+domainLength+2 { return nil, errors.New("Socks|UDP: Insufficient length of packet.") } domain := string(packet[5 : 5+domainLength]) request.Port = v2net.PortFromBytes(packet[5+domainLength : 5+domainLength+2]) request.Address = v2net.ParseAddress(domain) dataBegin = 5 + domainLength + 2 default: return nil, errors.Format("Socks|UDP: Unknown address type %d", addrType) } if len(packet) > dataBegin { b := buf.NewSmall() b.Append(packet[dataBegin:]) request.Data = b } return request, nil }
func (v *ClientSession) DecodeResponseHeader(reader io.Reader) (*protocol.ResponseHeader, error) { aesStream := crypto.NewAesDecryptionStream(v.responseBodyKey, v.responseBodyIV) v.responseReader = crypto.NewCryptionReader(aesStream, reader) buffer := make([]byte, 256) _, err := io.ReadFull(v.responseReader, buffer[:4]) if err != nil { log.Info("VMess|Client: Failed to read response header: ", err) return nil, err } if buffer[0] != v.responseHeader { return nil, errors.Format("VMess|Client: Unexpected response header. Expecting %d but actually %d", v.responseHeader, buffer[0]) } header := &protocol.ResponseHeader{ Option: protocol.ResponseOption(buffer[1]), } if buffer[2] != 0 { cmdID := buffer[2] dataLen := int(buffer[3]) _, err := io.ReadFull(v.responseReader, buffer[:dataLen]) if err != nil { log.Info("VMess|Client: Failed to read response command: ", err) return nil, err } data := buffer[:dataLen] command, err := UnmarshalCommand(cmdID, data) if err == nil { header.Command = command } } return header, nil }