1// Copyright 2020 The Prometheus Authors 2// Licensed under the Apache License, Version 2.0 (the "License"); 3// you may not use this file except in compliance with the License. 4// You may obtain a copy of the License at 5// 6// http://www.apache.org/licenses/LICENSE-2.0 7// 8// Unless required by applicable law or agreed to in writing, software 9// distributed under the License is distributed on an "AS IS" BASIS, 10// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 11// See the License for the specific language governing permissions and 12// limitations under the License. 13 14package procfs 15 16import ( 17 "bufio" 18 "encoding/hex" 19 "fmt" 20 "io" 21 "net" 22 "os" 23 "strconv" 24 "strings" 25) 26 27const ( 28 // readLimit is used by io.LimitReader while reading the content of the 29 // /proc/net/udp{,6} files. The number of lines inside such a file is dynamic 30 // as each line represents a single used socket. 31 // In theory, the number of available sockets is 65535 (2^16 - 1) per IP. 32 // With e.g. 150 Byte per line and the maximum number of 65535, 33 // the reader needs to handle 150 Byte * 65535 =~ 10 MB for a single IP. 34 readLimit = 4294967296 // Byte -> 4 GiB 35) 36 37// this contains generic data structures for both udp and tcp sockets 38type ( 39 // NetIPSocket represents the contents of /proc/net/{t,u}dp{,6} file without the header. 40 NetIPSocket []*netIPSocketLine 41 42 // NetIPSocketSummary provides already computed values like the total queue lengths or 43 // the total number of used sockets. In contrast to NetIPSocket it does not collect 44 // the parsed lines into a slice. 45 NetIPSocketSummary struct { 46 // TxQueueLength shows the total queue length of all parsed tx_queue lengths. 47 TxQueueLength uint64 48 // RxQueueLength shows the total queue length of all parsed rx_queue lengths. 49 RxQueueLength uint64 50 // UsedSockets shows the total number of parsed lines representing the 51 // number of used sockets. 52 UsedSockets uint64 53 } 54 55 // netIPSocketLine represents the fields parsed from a single line 56 // in /proc/net/{t,u}dp{,6}. Fields which are not used by IPSocket are skipped. 57 // For the proc file format details, see https://linux.die.net/man/5/proc. 58 netIPSocketLine struct { 59 Sl uint64 60 LocalAddr net.IP 61 LocalPort uint64 62 RemAddr net.IP 63 RemPort uint64 64 St uint64 65 TxQueue uint64 66 RxQueue uint64 67 UID uint64 68 } 69) 70 71func newNetIPSocket(file string) (NetIPSocket, error) { 72 f, err := os.Open(file) 73 if err != nil { 74 return nil, err 75 } 76 defer f.Close() 77 78 var netIPSocket NetIPSocket 79 80 lr := io.LimitReader(f, readLimit) 81 s := bufio.NewScanner(lr) 82 s.Scan() // skip first line with headers 83 for s.Scan() { 84 fields := strings.Fields(s.Text()) 85 line, err := parseNetIPSocketLine(fields) 86 if err != nil { 87 return nil, err 88 } 89 netIPSocket = append(netIPSocket, line) 90 } 91 if err := s.Err(); err != nil { 92 return nil, err 93 } 94 return netIPSocket, nil 95} 96 97// newNetIPSocketSummary creates a new NetIPSocket{,6} from the contents of the given file. 98func newNetIPSocketSummary(file string) (*NetIPSocketSummary, error) { 99 f, err := os.Open(file) 100 if err != nil { 101 return nil, err 102 } 103 defer f.Close() 104 105 var netIPSocketSummary NetIPSocketSummary 106 107 lr := io.LimitReader(f, readLimit) 108 s := bufio.NewScanner(lr) 109 s.Scan() // skip first line with headers 110 for s.Scan() { 111 fields := strings.Fields(s.Text()) 112 line, err := parseNetIPSocketLine(fields) 113 if err != nil { 114 return nil, err 115 } 116 netIPSocketSummary.TxQueueLength += line.TxQueue 117 netIPSocketSummary.RxQueueLength += line.RxQueue 118 netIPSocketSummary.UsedSockets++ 119 } 120 if err := s.Err(); err != nil { 121 return nil, err 122 } 123 return &netIPSocketSummary, nil 124} 125 126// the /proc/net/{t,u}dp{,6} files are network byte order for ipv4 and for ipv6 the address is four words consisting of four bytes each. In each of those four words the four bytes are written in reverse order. 127 128func parseIP(hexIP string) (net.IP, error) { 129 var byteIP []byte 130 byteIP, err := hex.DecodeString(hexIP) 131 if err != nil { 132 return nil, fmt.Errorf("cannot parse address field in socket line %q", hexIP) 133 } 134 switch len(byteIP) { 135 case 4: 136 return net.IP{byteIP[3], byteIP[2], byteIP[1], byteIP[0]}, nil 137 case 16: 138 i := net.IP{ 139 byteIP[3], byteIP[2], byteIP[1], byteIP[0], 140 byteIP[7], byteIP[6], byteIP[5], byteIP[4], 141 byteIP[11], byteIP[10], byteIP[9], byteIP[8], 142 byteIP[15], byteIP[14], byteIP[13], byteIP[12], 143 } 144 return i, nil 145 default: 146 return nil, fmt.Errorf("Unable to parse IP %s", hexIP) 147 } 148} 149 150// parseNetIPSocketLine parses a single line, represented by a list of fields. 151func parseNetIPSocketLine(fields []string) (*netIPSocketLine, error) { 152 line := &netIPSocketLine{} 153 if len(fields) < 8 { 154 return nil, fmt.Errorf( 155 "cannot parse net socket line as it has less then 8 columns %q", 156 strings.Join(fields, " "), 157 ) 158 } 159 var err error // parse error 160 161 // sl 162 s := strings.Split(fields[0], ":") 163 if len(s) != 2 { 164 return nil, fmt.Errorf("cannot parse sl field in socket line %q", fields[0]) 165 } 166 167 if line.Sl, err = strconv.ParseUint(s[0], 0, 64); err != nil { 168 return nil, fmt.Errorf("cannot parse sl value in socket line: %w", err) 169 } 170 // local_address 171 l := strings.Split(fields[1], ":") 172 if len(l) != 2 { 173 return nil, fmt.Errorf("cannot parse local_address field in socket line %q", fields[1]) 174 } 175 if line.LocalAddr, err = parseIP(l[0]); err != nil { 176 return nil, err 177 } 178 if line.LocalPort, err = strconv.ParseUint(l[1], 16, 64); err != nil { 179 return nil, fmt.Errorf("cannot parse local_address port value in socket line: %w", err) 180 } 181 182 // remote_address 183 r := strings.Split(fields[2], ":") 184 if len(r) != 2 { 185 return nil, fmt.Errorf("cannot parse rem_address field in socket line %q", fields[1]) 186 } 187 if line.RemAddr, err = parseIP(r[0]); err != nil { 188 return nil, err 189 } 190 if line.RemPort, err = strconv.ParseUint(r[1], 16, 64); err != nil { 191 return nil, fmt.Errorf("cannot parse rem_address port value in socket line: %w", err) 192 } 193 194 // st 195 if line.St, err = strconv.ParseUint(fields[3], 16, 64); err != nil { 196 return nil, fmt.Errorf("cannot parse st value in socket line: %w", err) 197 } 198 199 // tx_queue and rx_queue 200 q := strings.Split(fields[4], ":") 201 if len(q) != 2 { 202 return nil, fmt.Errorf( 203 "cannot parse tx/rx queues in socket line as it has a missing colon %q", 204 fields[4], 205 ) 206 } 207 if line.TxQueue, err = strconv.ParseUint(q[0], 16, 64); err != nil { 208 return nil, fmt.Errorf("cannot parse tx_queue value in socket line: %w", err) 209 } 210 if line.RxQueue, err = strconv.ParseUint(q[1], 16, 64); err != nil { 211 return nil, fmt.Errorf("cannot parse rx_queue value in socket line: %w", err) 212 } 213 214 // uid 215 if line.UID, err = strconv.ParseUint(fields[7], 0, 64); err != nil { 216 return nil, fmt.Errorf("cannot parse uid value in socket line: %w", err) 217 } 218 219 return line, nil 220} 221