syscall_linux.go 74 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426427428429430431432433434435436437438439440441442443444445446447448449450451452453454455456457458459460461462463464465466467468469470471472473474475476477478479480481482483484485486487488489490491492493494495496497498499500501502503504505506507508509510511512513514515516517518519520521522523524525526527528529530531532533534535536537538539540541542543544545546547548549550551552553554555556557558559560561562563564565566567568569570571572573574575576577578579580581582583584585586587588589590591592593594595596597598599600601602603604605606607608609610611612613614615616617618619620621622623624625626627628629630631632633634635636637638639640641642643644645646647648649650651652653654655656657658659660661662663664665666667668669670671672673674675676677678679680681682683684685686687688689690691692693694695696697698699700701702703704705706707708709710711712713714715716717718719720721722723724725726727728729730731732733734735736737738739740741742743744745746747748749750751752753754755756757758759760761762763764765766767768769770771772773774775776777778779780781782783784785786787788789790791792793794795796797798799800801802803804805806807808809810811812813814815816817818819820821822823824825826827828829830831832833834835836837838839840841842843844845846847848849850851852853854855856857858859860861862863864865866867868869870871872873874875876877878879880881882883884885886887888889890891892893894895896897898899900901902903904905906907908909910911912913914915916917918919920921922923924925926927928929930931932933934935936937938939940941942943944945946947948949950951952953954955956957958959960961962963964965966967968969970971972973974975976977978979980981982983984985986987988989990991992993994995996997998999100010011002100310041005100610071008100910101011101210131014101510161017101810191020102110221023102410251026102710281029103010311032103310341035103610371038103910401041104210431044104510461047104810491050105110521053105410551056105710581059106010611062106310641065106610671068106910701071107210731074107510761077107810791080108110821083108410851086108710881089109010911092109310941095109610971098109911001101110211031104110511061107110811091110111111121113111411151116111711181119112011211122112311241125112611271128112911301131113211331134113511361137113811391140114111421143114411451146114711481149115011511152115311541155115611571158115911601161116211631164116511661167116811691170117111721173117411751176117711781179118011811182118311841185118611871188118911901191119211931194119511961197119811991200120112021203120412051206120712081209121012111212121312141215121612171218121912201221122212231224122512261227122812291230123112321233123412351236123712381239124012411242124312441245124612471248124912501251125212531254125512561257125812591260126112621263126412651266126712681269127012711272127312741275127612771278127912801281128212831284128512861287128812891290129112921293129412951296129712981299130013011302130313041305130613071308130913101311131213131314131513161317131813191320132113221323132413251326132713281329133013311332133313341335133613371338133913401341134213431344134513461347134813491350135113521353135413551356135713581359136013611362136313641365136613671368136913701371137213731374137513761377137813791380138113821383138413851386138713881389139013911392139313941395139613971398139914001401140214031404140514061407140814091410141114121413141414151416141714181419142014211422142314241425142614271428142914301431143214331434143514361437143814391440144114421443144414451446144714481449145014511452145314541455145614571458145914601461146214631464146514661467146814691470147114721473147414751476147714781479148014811482148314841485148614871488148914901491149214931494149514961497149814991500150115021503150415051506150715081509151015111512151315141515151615171518151915201521152215231524152515261527152815291530153115321533153415351536153715381539154015411542154315441545154615471548154915501551155215531554155515561557155815591560156115621563156415651566156715681569157015711572157315741575157615771578157915801581158215831584158515861587158815891590159115921593159415951596159715981599160016011602160316041605160616071608160916101611161216131614161516161617161816191620162116221623162416251626162716281629163016311632163316341635163616371638163916401641164216431644164516461647164816491650165116521653165416551656165716581659166016611662166316641665166616671668166916701671167216731674167516761677167816791680168116821683168416851686168716881689169016911692169316941695169616971698169917001701170217031704170517061707170817091710171117121713171417151716171717181719172017211722172317241725172617271728172917301731173217331734173517361737173817391740174117421743174417451746174717481749175017511752175317541755175617571758175917601761176217631764176517661767176817691770177117721773177417751776177717781779178017811782178317841785178617871788178917901791179217931794179517961797179817991800180118021803180418051806180718081809181018111812181318141815181618171818181918201821182218231824182518261827182818291830183118321833183418351836183718381839184018411842184318441845184618471848184918501851185218531854185518561857185818591860186118621863186418651866186718681869187018711872187318741875187618771878187918801881188218831884188518861887188818891890189118921893189418951896189718981899190019011902190319041905190619071908190919101911191219131914191519161917191819191920192119221923192419251926192719281929193019311932193319341935193619371938193919401941194219431944194519461947194819491950195119521953195419551956195719581959196019611962196319641965196619671968196919701971197219731974197519761977197819791980198119821983198419851986198719881989199019911992199319941995199619971998199920002001200220032004200520062007200820092010201120122013201420152016201720182019202020212022202320242025202620272028202920302031203220332034203520362037203820392040204120422043204420452046204720482049205020512052205320542055205620572058205920602061206220632064206520662067206820692070207120722073207420752076207720782079208020812082208320842085208620872088208920902091209220932094209520962097209820992100210121022103210421052106210721082109211021112112211321142115211621172118211921202121212221232124212521262127212821292130213121322133213421352136213721382139214021412142214321442145214621472148214921502151215221532154215521562157215821592160216121622163216421652166216721682169217021712172217321742175217621772178217921802181218221832184218521862187218821892190219121922193219421952196219721982199220022012202220322042205220622072208220922102211221222132214221522162217221822192220222122222223222422252226222722282229223022312232223322342235223622372238223922402241224222432244224522462247224822492250225122522253225422552256225722582259226022612262226322642265226622672268226922702271227222732274227522762277227822792280228122822283228422852286228722882289229022912292229322942295229622972298229923002301230223032304230523062307230823092310231123122313231423152316231723182319232023212322232323242325232623272328232923302331233223332334233523362337233823392340234123422343234423452346234723482349235023512352235323542355235623572358235923602361236223632364236523662367236823692370237123722373237423752376237723782379238023812382238323842385238623872388238923902391239223932394239523962397239823992400240124022403240424052406240724082409241024112412241324142415241624172418241924202421242224232424242524262427242824292430243124322433243424352436243724382439244024412442244324442445244624472448244924502451245224532454245524562457245824592460246124622463246424652466246724682469247024712472247324742475247624772478247924802481248224832484
  1. // Copyright 2009 The Go Authors. All rights reserved.
  2. // Use of this source code is governed by a BSD-style
  3. // license that can be found in the LICENSE file.
  4. // Linux system calls.
  5. // This file is compiled as ordinary Go code,
  6. // but it is also input to mksyscall,
  7. // which parses the //sys lines and generates system call stubs.
  8. // Note that sometimes we use a lowercase //sys name and
  9. // wrap it in our own nicer implementation.
  10. package unix
  11. import (
  12. "encoding/binary"
  13. "strconv"
  14. "syscall"
  15. "time"
  16. "unsafe"
  17. )
  18. /*
  19. * Wrapped
  20. */
  21. func Access(path string, mode uint32) (err error) {
  22. return Faccessat(AT_FDCWD, path, mode, 0)
  23. }
  24. func Chmod(path string, mode uint32) (err error) {
  25. return Fchmodat(AT_FDCWD, path, mode, 0)
  26. }
  27. func Chown(path string, uid int, gid int) (err error) {
  28. return Fchownat(AT_FDCWD, path, uid, gid, 0)
  29. }
  30. func Creat(path string, mode uint32) (fd int, err error) {
  31. return Open(path, O_CREAT|O_WRONLY|O_TRUNC, mode)
  32. }
  33. func EpollCreate(size int) (fd int, err error) {
  34. if size <= 0 {
  35. return -1, EINVAL
  36. }
  37. return EpollCreate1(0)
  38. }
  39. //sys FanotifyInit(flags uint, event_f_flags uint) (fd int, err error)
  40. //sys fanotifyMark(fd int, flags uint, mask uint64, dirFd int, pathname *byte) (err error)
  41. func FanotifyMark(fd int, flags uint, mask uint64, dirFd int, pathname string) (err error) {
  42. if pathname == "" {
  43. return fanotifyMark(fd, flags, mask, dirFd, nil)
  44. }
  45. p, err := BytePtrFromString(pathname)
  46. if err != nil {
  47. return err
  48. }
  49. return fanotifyMark(fd, flags, mask, dirFd, p)
  50. }
  51. //sys fchmodat(dirfd int, path string, mode uint32) (err error)
  52. func Fchmodat(dirfd int, path string, mode uint32, flags int) (err error) {
  53. // Linux fchmodat doesn't support the flags parameter. Mimick glibc's behavior
  54. // and check the flags. Otherwise the mode would be applied to the symlink
  55. // destination which is not what the user expects.
  56. if flags&^AT_SYMLINK_NOFOLLOW != 0 {
  57. return EINVAL
  58. } else if flags&AT_SYMLINK_NOFOLLOW != 0 {
  59. return EOPNOTSUPP
  60. }
  61. return fchmodat(dirfd, path, mode)
  62. }
  63. func InotifyInit() (fd int, err error) {
  64. return InotifyInit1(0)
  65. }
  66. //sys ioctl(fd int, req uint, arg uintptr) (err error) = SYS_IOCTL
  67. //sys ioctlPtr(fd int, req uint, arg unsafe.Pointer) (err error) = SYS_IOCTL
  68. // ioctl itself should not be exposed directly, but additional get/set functions
  69. // for specific types are permissible. These are defined in ioctl.go and
  70. // ioctl_linux.go.
  71. //
  72. // The third argument to ioctl is often a pointer but sometimes an integer.
  73. // Callers should use ioctlPtr when the third argument is a pointer and ioctl
  74. // when the third argument is an integer.
  75. //
  76. // TODO: some existing code incorrectly uses ioctl when it should use ioctlPtr.
  77. //sys Linkat(olddirfd int, oldpath string, newdirfd int, newpath string, flags int) (err error)
  78. func Link(oldpath string, newpath string) (err error) {
  79. return Linkat(AT_FDCWD, oldpath, AT_FDCWD, newpath, 0)
  80. }
  81. func Mkdir(path string, mode uint32) (err error) {
  82. return Mkdirat(AT_FDCWD, path, mode)
  83. }
  84. func Mknod(path string, mode uint32, dev int) (err error) {
  85. return Mknodat(AT_FDCWD, path, mode, dev)
  86. }
  87. func Open(path string, mode int, perm uint32) (fd int, err error) {
  88. return openat(AT_FDCWD, path, mode|O_LARGEFILE, perm)
  89. }
  90. //sys openat(dirfd int, path string, flags int, mode uint32) (fd int, err error)
  91. func Openat(dirfd int, path string, flags int, mode uint32) (fd int, err error) {
  92. return openat(dirfd, path, flags|O_LARGEFILE, mode)
  93. }
  94. //sys openat2(dirfd int, path string, open_how *OpenHow, size int) (fd int, err error)
  95. func Openat2(dirfd int, path string, how *OpenHow) (fd int, err error) {
  96. return openat2(dirfd, path, how, SizeofOpenHow)
  97. }
  98. func Pipe(p []int) error {
  99. return Pipe2(p, 0)
  100. }
  101. //sysnb pipe2(p *[2]_C_int, flags int) (err error)
  102. func Pipe2(p []int, flags int) error {
  103. if len(p) != 2 {
  104. return EINVAL
  105. }
  106. var pp [2]_C_int
  107. err := pipe2(&pp, flags)
  108. if err == nil {
  109. p[0] = int(pp[0])
  110. p[1] = int(pp[1])
  111. }
  112. return err
  113. }
  114. //sys ppoll(fds *PollFd, nfds int, timeout *Timespec, sigmask *Sigset_t) (n int, err error)
  115. func Ppoll(fds []PollFd, timeout *Timespec, sigmask *Sigset_t) (n int, err error) {
  116. if len(fds) == 0 {
  117. return ppoll(nil, 0, timeout, sigmask)
  118. }
  119. return ppoll(&fds[0], len(fds), timeout, sigmask)
  120. }
  121. func Poll(fds []PollFd, timeout int) (n int, err error) {
  122. var ts *Timespec
  123. if timeout >= 0 {
  124. ts = new(Timespec)
  125. *ts = NsecToTimespec(int64(timeout) * 1e6)
  126. }
  127. return Ppoll(fds, ts, nil)
  128. }
  129. //sys Readlinkat(dirfd int, path string, buf []byte) (n int, err error)
  130. func Readlink(path string, buf []byte) (n int, err error) {
  131. return Readlinkat(AT_FDCWD, path, buf)
  132. }
  133. func Rename(oldpath string, newpath string) (err error) {
  134. return Renameat(AT_FDCWD, oldpath, AT_FDCWD, newpath)
  135. }
  136. func Rmdir(path string) error {
  137. return Unlinkat(AT_FDCWD, path, AT_REMOVEDIR)
  138. }
  139. //sys Symlinkat(oldpath string, newdirfd int, newpath string) (err error)
  140. func Symlink(oldpath string, newpath string) (err error) {
  141. return Symlinkat(oldpath, AT_FDCWD, newpath)
  142. }
  143. func Unlink(path string) error {
  144. return Unlinkat(AT_FDCWD, path, 0)
  145. }
  146. //sys Unlinkat(dirfd int, path string, flags int) (err error)
  147. func Utimes(path string, tv []Timeval) error {
  148. if tv == nil {
  149. err := utimensat(AT_FDCWD, path, nil, 0)
  150. if err != ENOSYS {
  151. return err
  152. }
  153. return utimes(path, nil)
  154. }
  155. if len(tv) != 2 {
  156. return EINVAL
  157. }
  158. var ts [2]Timespec
  159. ts[0] = NsecToTimespec(TimevalToNsec(tv[0]))
  160. ts[1] = NsecToTimespec(TimevalToNsec(tv[1]))
  161. err := utimensat(AT_FDCWD, path, (*[2]Timespec)(unsafe.Pointer(&ts[0])), 0)
  162. if err != ENOSYS {
  163. return err
  164. }
  165. return utimes(path, (*[2]Timeval)(unsafe.Pointer(&tv[0])))
  166. }
  167. //sys utimensat(dirfd int, path string, times *[2]Timespec, flags int) (err error)
  168. func UtimesNano(path string, ts []Timespec) error {
  169. return UtimesNanoAt(AT_FDCWD, path, ts, 0)
  170. }
  171. func UtimesNanoAt(dirfd int, path string, ts []Timespec, flags int) error {
  172. if ts == nil {
  173. return utimensat(dirfd, path, nil, flags)
  174. }
  175. if len(ts) != 2 {
  176. return EINVAL
  177. }
  178. return utimensat(dirfd, path, (*[2]Timespec)(unsafe.Pointer(&ts[0])), flags)
  179. }
  180. func Futimesat(dirfd int, path string, tv []Timeval) error {
  181. if tv == nil {
  182. return futimesat(dirfd, path, nil)
  183. }
  184. if len(tv) != 2 {
  185. return EINVAL
  186. }
  187. return futimesat(dirfd, path, (*[2]Timeval)(unsafe.Pointer(&tv[0])))
  188. }
  189. func Futimes(fd int, tv []Timeval) (err error) {
  190. // Believe it or not, this is the best we can do on Linux
  191. // (and is what glibc does).
  192. return Utimes("/proc/self/fd/"+strconv.Itoa(fd), tv)
  193. }
  194. const ImplementsGetwd = true
  195. //sys Getcwd(buf []byte) (n int, err error)
  196. func Getwd() (wd string, err error) {
  197. var buf [PathMax]byte
  198. n, err := Getcwd(buf[0:])
  199. if err != nil {
  200. return "", err
  201. }
  202. // Getcwd returns the number of bytes written to buf, including the NUL.
  203. if n < 1 || n > len(buf) || buf[n-1] != 0 {
  204. return "", EINVAL
  205. }
  206. // In some cases, Linux can return a path that starts with the
  207. // "(unreachable)" prefix, which can potentially be a valid relative
  208. // path. To work around that, return ENOENT if path is not absolute.
  209. if buf[0] != '/' {
  210. return "", ENOENT
  211. }
  212. return string(buf[0 : n-1]), nil
  213. }
  214. func Getgroups() (gids []int, err error) {
  215. n, err := getgroups(0, nil)
  216. if err != nil {
  217. return nil, err
  218. }
  219. if n == 0 {
  220. return nil, nil
  221. }
  222. // Sanity check group count. Max is 1<<16 on Linux.
  223. if n < 0 || n > 1<<20 {
  224. return nil, EINVAL
  225. }
  226. a := make([]_Gid_t, n)
  227. n, err = getgroups(n, &a[0])
  228. if err != nil {
  229. return nil, err
  230. }
  231. gids = make([]int, n)
  232. for i, v := range a[0:n] {
  233. gids[i] = int(v)
  234. }
  235. return
  236. }
  237. func Setgroups(gids []int) (err error) {
  238. if len(gids) == 0 {
  239. return setgroups(0, nil)
  240. }
  241. a := make([]_Gid_t, len(gids))
  242. for i, v := range gids {
  243. a[i] = _Gid_t(v)
  244. }
  245. return setgroups(len(a), &a[0])
  246. }
  247. type WaitStatus uint32
  248. // Wait status is 7 bits at bottom, either 0 (exited),
  249. // 0x7F (stopped), or a signal number that caused an exit.
  250. // The 0x80 bit is whether there was a core dump.
  251. // An extra number (exit code, signal causing a stop)
  252. // is in the high bits. At least that's the idea.
  253. // There are various irregularities. For example, the
  254. // "continued" status is 0xFFFF, distinguishing itself
  255. // from stopped via the core dump bit.
  256. const (
  257. mask = 0x7F
  258. core = 0x80
  259. exited = 0x00
  260. stopped = 0x7F
  261. shift = 8
  262. )
  263. func (w WaitStatus) Exited() bool { return w&mask == exited }
  264. func (w WaitStatus) Signaled() bool { return w&mask != stopped && w&mask != exited }
  265. func (w WaitStatus) Stopped() bool { return w&0xFF == stopped }
  266. func (w WaitStatus) Continued() bool { return w == 0xFFFF }
  267. func (w WaitStatus) CoreDump() bool { return w.Signaled() && w&core != 0 }
  268. func (w WaitStatus) ExitStatus() int {
  269. if !w.Exited() {
  270. return -1
  271. }
  272. return int(w>>shift) & 0xFF
  273. }
  274. func (w WaitStatus) Signal() syscall.Signal {
  275. if !w.Signaled() {
  276. return -1
  277. }
  278. return syscall.Signal(w & mask)
  279. }
  280. func (w WaitStatus) StopSignal() syscall.Signal {
  281. if !w.Stopped() {
  282. return -1
  283. }
  284. return syscall.Signal(w>>shift) & 0xFF
  285. }
  286. func (w WaitStatus) TrapCause() int {
  287. if w.StopSignal() != SIGTRAP {
  288. return -1
  289. }
  290. return int(w>>shift) >> 8
  291. }
  292. //sys wait4(pid int, wstatus *_C_int, options int, rusage *Rusage) (wpid int, err error)
  293. func Wait4(pid int, wstatus *WaitStatus, options int, rusage *Rusage) (wpid int, err error) {
  294. var status _C_int
  295. wpid, err = wait4(pid, &status, options, rusage)
  296. if wstatus != nil {
  297. *wstatus = WaitStatus(status)
  298. }
  299. return
  300. }
  301. //sys Waitid(idType int, id int, info *Siginfo, options int, rusage *Rusage) (err error)
  302. func Mkfifo(path string, mode uint32) error {
  303. return Mknod(path, mode|S_IFIFO, 0)
  304. }
  305. func Mkfifoat(dirfd int, path string, mode uint32) error {
  306. return Mknodat(dirfd, path, mode|S_IFIFO, 0)
  307. }
  308. func (sa *SockaddrInet4) sockaddr() (unsafe.Pointer, _Socklen, error) {
  309. if sa.Port < 0 || sa.Port > 0xFFFF {
  310. return nil, 0, EINVAL
  311. }
  312. sa.raw.Family = AF_INET
  313. p := (*[2]byte)(unsafe.Pointer(&sa.raw.Port))
  314. p[0] = byte(sa.Port >> 8)
  315. p[1] = byte(sa.Port)
  316. sa.raw.Addr = sa.Addr
  317. return unsafe.Pointer(&sa.raw), SizeofSockaddrInet4, nil
  318. }
  319. func (sa *SockaddrInet6) sockaddr() (unsafe.Pointer, _Socklen, error) {
  320. if sa.Port < 0 || sa.Port > 0xFFFF {
  321. return nil, 0, EINVAL
  322. }
  323. sa.raw.Family = AF_INET6
  324. p := (*[2]byte)(unsafe.Pointer(&sa.raw.Port))
  325. p[0] = byte(sa.Port >> 8)
  326. p[1] = byte(sa.Port)
  327. sa.raw.Scope_id = sa.ZoneId
  328. sa.raw.Addr = sa.Addr
  329. return unsafe.Pointer(&sa.raw), SizeofSockaddrInet6, nil
  330. }
  331. func (sa *SockaddrUnix) sockaddr() (unsafe.Pointer, _Socklen, error) {
  332. name := sa.Name
  333. n := len(name)
  334. if n >= len(sa.raw.Path) {
  335. return nil, 0, EINVAL
  336. }
  337. sa.raw.Family = AF_UNIX
  338. for i := 0; i < n; i++ {
  339. sa.raw.Path[i] = int8(name[i])
  340. }
  341. // length is family (uint16), name, NUL.
  342. sl := _Socklen(2)
  343. if n > 0 {
  344. sl += _Socklen(n) + 1
  345. }
  346. if sa.raw.Path[0] == '@' {
  347. sa.raw.Path[0] = 0
  348. // Don't count trailing NUL for abstract address.
  349. sl--
  350. }
  351. return unsafe.Pointer(&sa.raw), sl, nil
  352. }
  353. // SockaddrLinklayer implements the Sockaddr interface for AF_PACKET type sockets.
  354. type SockaddrLinklayer struct {
  355. Protocol uint16
  356. Ifindex int
  357. Hatype uint16
  358. Pkttype uint8
  359. Halen uint8
  360. Addr [8]byte
  361. raw RawSockaddrLinklayer
  362. }
  363. func (sa *SockaddrLinklayer) sockaddr() (unsafe.Pointer, _Socklen, error) {
  364. if sa.Ifindex < 0 || sa.Ifindex > 0x7fffffff {
  365. return nil, 0, EINVAL
  366. }
  367. sa.raw.Family = AF_PACKET
  368. sa.raw.Protocol = sa.Protocol
  369. sa.raw.Ifindex = int32(sa.Ifindex)
  370. sa.raw.Hatype = sa.Hatype
  371. sa.raw.Pkttype = sa.Pkttype
  372. sa.raw.Halen = sa.Halen
  373. sa.raw.Addr = sa.Addr
  374. return unsafe.Pointer(&sa.raw), SizeofSockaddrLinklayer, nil
  375. }
  376. // SockaddrNetlink implements the Sockaddr interface for AF_NETLINK type sockets.
  377. type SockaddrNetlink struct {
  378. Family uint16
  379. Pad uint16
  380. Pid uint32
  381. Groups uint32
  382. raw RawSockaddrNetlink
  383. }
  384. func (sa *SockaddrNetlink) sockaddr() (unsafe.Pointer, _Socklen, error) {
  385. sa.raw.Family = AF_NETLINK
  386. sa.raw.Pad = sa.Pad
  387. sa.raw.Pid = sa.Pid
  388. sa.raw.Groups = sa.Groups
  389. return unsafe.Pointer(&sa.raw), SizeofSockaddrNetlink, nil
  390. }
  391. // SockaddrHCI implements the Sockaddr interface for AF_BLUETOOTH type sockets
  392. // using the HCI protocol.
  393. type SockaddrHCI struct {
  394. Dev uint16
  395. Channel uint16
  396. raw RawSockaddrHCI
  397. }
  398. func (sa *SockaddrHCI) sockaddr() (unsafe.Pointer, _Socklen, error) {
  399. sa.raw.Family = AF_BLUETOOTH
  400. sa.raw.Dev = sa.Dev
  401. sa.raw.Channel = sa.Channel
  402. return unsafe.Pointer(&sa.raw), SizeofSockaddrHCI, nil
  403. }
  404. // SockaddrL2 implements the Sockaddr interface for AF_BLUETOOTH type sockets
  405. // using the L2CAP protocol.
  406. type SockaddrL2 struct {
  407. PSM uint16
  408. CID uint16
  409. Addr [6]uint8
  410. AddrType uint8
  411. raw RawSockaddrL2
  412. }
  413. func (sa *SockaddrL2) sockaddr() (unsafe.Pointer, _Socklen, error) {
  414. sa.raw.Family = AF_BLUETOOTH
  415. psm := (*[2]byte)(unsafe.Pointer(&sa.raw.Psm))
  416. psm[0] = byte(sa.PSM)
  417. psm[1] = byte(sa.PSM >> 8)
  418. for i := 0; i < len(sa.Addr); i++ {
  419. sa.raw.Bdaddr[i] = sa.Addr[len(sa.Addr)-1-i]
  420. }
  421. cid := (*[2]byte)(unsafe.Pointer(&sa.raw.Cid))
  422. cid[0] = byte(sa.CID)
  423. cid[1] = byte(sa.CID >> 8)
  424. sa.raw.Bdaddr_type = sa.AddrType
  425. return unsafe.Pointer(&sa.raw), SizeofSockaddrL2, nil
  426. }
  427. // SockaddrRFCOMM implements the Sockaddr interface for AF_BLUETOOTH type sockets
  428. // using the RFCOMM protocol.
  429. //
  430. // Server example:
  431. //
  432. // fd, _ := Socket(AF_BLUETOOTH, SOCK_STREAM, BTPROTO_RFCOMM)
  433. // _ = unix.Bind(fd, &unix.SockaddrRFCOMM{
  434. // Channel: 1,
  435. // Addr: [6]uint8{0, 0, 0, 0, 0, 0}, // BDADDR_ANY or 00:00:00:00:00:00
  436. // })
  437. // _ = Listen(fd, 1)
  438. // nfd, sa, _ := Accept(fd)
  439. // fmt.Printf("conn addr=%v fd=%d", sa.(*unix.SockaddrRFCOMM).Addr, nfd)
  440. // Read(nfd, buf)
  441. //
  442. // Client example:
  443. //
  444. // fd, _ := Socket(AF_BLUETOOTH, SOCK_STREAM, BTPROTO_RFCOMM)
  445. // _ = Connect(fd, &SockaddrRFCOMM{
  446. // Channel: 1,
  447. // Addr: [6]byte{0x11, 0x22, 0x33, 0xaa, 0xbb, 0xcc}, // CC:BB:AA:33:22:11
  448. // })
  449. // Write(fd, []byte(`hello`))
  450. type SockaddrRFCOMM struct {
  451. // Addr represents a bluetooth address, byte ordering is little-endian.
  452. Addr [6]uint8
  453. // Channel is a designated bluetooth channel, only 1-30 are available for use.
  454. // Since Linux 2.6.7 and further zero value is the first available channel.
  455. Channel uint8
  456. raw RawSockaddrRFCOMM
  457. }
  458. func (sa *SockaddrRFCOMM) sockaddr() (unsafe.Pointer, _Socklen, error) {
  459. sa.raw.Family = AF_BLUETOOTH
  460. sa.raw.Channel = sa.Channel
  461. sa.raw.Bdaddr = sa.Addr
  462. return unsafe.Pointer(&sa.raw), SizeofSockaddrRFCOMM, nil
  463. }
  464. // SockaddrCAN implements the Sockaddr interface for AF_CAN type sockets.
  465. // The RxID and TxID fields are used for transport protocol addressing in
  466. // (CAN_TP16, CAN_TP20, CAN_MCNET, and CAN_ISOTP), they can be left with
  467. // zero values for CAN_RAW and CAN_BCM sockets as they have no meaning.
  468. //
  469. // The SockaddrCAN struct must be bound to the socket file descriptor
  470. // using Bind before the CAN socket can be used.
  471. //
  472. // // Read one raw CAN frame
  473. // fd, _ := Socket(AF_CAN, SOCK_RAW, CAN_RAW)
  474. // addr := &SockaddrCAN{Ifindex: index}
  475. // Bind(fd, addr)
  476. // frame := make([]byte, 16)
  477. // Read(fd, frame)
  478. //
  479. // The full SocketCAN documentation can be found in the linux kernel
  480. // archives at: https://www.kernel.org/doc/Documentation/networking/can.txt
  481. type SockaddrCAN struct {
  482. Ifindex int
  483. RxID uint32
  484. TxID uint32
  485. raw RawSockaddrCAN
  486. }
  487. func (sa *SockaddrCAN) sockaddr() (unsafe.Pointer, _Socklen, error) {
  488. if sa.Ifindex < 0 || sa.Ifindex > 0x7fffffff {
  489. return nil, 0, EINVAL
  490. }
  491. sa.raw.Family = AF_CAN
  492. sa.raw.Ifindex = int32(sa.Ifindex)
  493. rx := (*[4]byte)(unsafe.Pointer(&sa.RxID))
  494. for i := 0; i < 4; i++ {
  495. sa.raw.Addr[i] = rx[i]
  496. }
  497. tx := (*[4]byte)(unsafe.Pointer(&sa.TxID))
  498. for i := 0; i < 4; i++ {
  499. sa.raw.Addr[i+4] = tx[i]
  500. }
  501. return unsafe.Pointer(&sa.raw), SizeofSockaddrCAN, nil
  502. }
  503. // SockaddrCANJ1939 implements the Sockaddr interface for AF_CAN using J1939
  504. // protocol (https://en.wikipedia.org/wiki/SAE_J1939). For more information
  505. // on the purposes of the fields, check the official linux kernel documentation
  506. // available here: https://www.kernel.org/doc/Documentation/networking/j1939.rst
  507. type SockaddrCANJ1939 struct {
  508. Ifindex int
  509. Name uint64
  510. PGN uint32
  511. Addr uint8
  512. raw RawSockaddrCAN
  513. }
  514. func (sa *SockaddrCANJ1939) sockaddr() (unsafe.Pointer, _Socklen, error) {
  515. if sa.Ifindex < 0 || sa.Ifindex > 0x7fffffff {
  516. return nil, 0, EINVAL
  517. }
  518. sa.raw.Family = AF_CAN
  519. sa.raw.Ifindex = int32(sa.Ifindex)
  520. n := (*[8]byte)(unsafe.Pointer(&sa.Name))
  521. for i := 0; i < 8; i++ {
  522. sa.raw.Addr[i] = n[i]
  523. }
  524. p := (*[4]byte)(unsafe.Pointer(&sa.PGN))
  525. for i := 0; i < 4; i++ {
  526. sa.raw.Addr[i+8] = p[i]
  527. }
  528. sa.raw.Addr[12] = sa.Addr
  529. return unsafe.Pointer(&sa.raw), SizeofSockaddrCAN, nil
  530. }
  531. // SockaddrALG implements the Sockaddr interface for AF_ALG type sockets.
  532. // SockaddrALG enables userspace access to the Linux kernel's cryptography
  533. // subsystem. The Type and Name fields specify which type of hash or cipher
  534. // should be used with a given socket.
  535. //
  536. // To create a file descriptor that provides access to a hash or cipher, both
  537. // Bind and Accept must be used. Once the setup process is complete, input
  538. // data can be written to the socket, processed by the kernel, and then read
  539. // back as hash output or ciphertext.
  540. //
  541. // Here is an example of using an AF_ALG socket with SHA1 hashing.
  542. // The initial socket setup process is as follows:
  543. //
  544. // // Open a socket to perform SHA1 hashing.
  545. // fd, _ := unix.Socket(unix.AF_ALG, unix.SOCK_SEQPACKET, 0)
  546. // addr := &unix.SockaddrALG{Type: "hash", Name: "sha1"}
  547. // unix.Bind(fd, addr)
  548. // // Note: unix.Accept does not work at this time; must invoke accept()
  549. // // manually using unix.Syscall.
  550. // hashfd, _, _ := unix.Syscall(unix.SYS_ACCEPT, uintptr(fd), 0, 0)
  551. //
  552. // Once a file descriptor has been returned from Accept, it may be used to
  553. // perform SHA1 hashing. The descriptor is not safe for concurrent use, but
  554. // may be re-used repeatedly with subsequent Write and Read operations.
  555. //
  556. // When hashing a small byte slice or string, a single Write and Read may
  557. // be used:
  558. //
  559. // // Assume hashfd is already configured using the setup process.
  560. // hash := os.NewFile(hashfd, "sha1")
  561. // // Hash an input string and read the results. Each Write discards
  562. // // previous hash state. Read always reads the current state.
  563. // b := make([]byte, 20)
  564. // for i := 0; i < 2; i++ {
  565. // io.WriteString(hash, "Hello, world.")
  566. // hash.Read(b)
  567. // fmt.Println(hex.EncodeToString(b))
  568. // }
  569. // // Output:
  570. // // 2ae01472317d1935a84797ec1983ae243fc6aa28
  571. // // 2ae01472317d1935a84797ec1983ae243fc6aa28
  572. //
  573. // For hashing larger byte slices, or byte streams such as those read from
  574. // a file or socket, use Sendto with MSG_MORE to instruct the kernel to update
  575. // the hash digest instead of creating a new one for a given chunk and finalizing it.
  576. //
  577. // // Assume hashfd and addr are already configured using the setup process.
  578. // hash := os.NewFile(hashfd, "sha1")
  579. // // Hash the contents of a file.
  580. // f, _ := os.Open("/tmp/linux-4.10-rc7.tar.xz")
  581. // b := make([]byte, 4096)
  582. // for {
  583. // n, err := f.Read(b)
  584. // if err == io.EOF {
  585. // break
  586. // }
  587. // unix.Sendto(hashfd, b[:n], unix.MSG_MORE, addr)
  588. // }
  589. // hash.Read(b)
  590. // fmt.Println(hex.EncodeToString(b))
  591. // // Output: 85cdcad0c06eef66f805ecce353bec9accbeecc5
  592. //
  593. // For more information, see: http://www.chronox.de/crypto-API/crypto/userspace-if.html.
  594. type SockaddrALG struct {
  595. Type string
  596. Name string
  597. Feature uint32
  598. Mask uint32
  599. raw RawSockaddrALG
  600. }
  601. func (sa *SockaddrALG) sockaddr() (unsafe.Pointer, _Socklen, error) {
  602. // Leave room for NUL byte terminator.
  603. if len(sa.Type) > len(sa.raw.Type)-1 {
  604. return nil, 0, EINVAL
  605. }
  606. if len(sa.Name) > len(sa.raw.Name)-1 {
  607. return nil, 0, EINVAL
  608. }
  609. sa.raw.Family = AF_ALG
  610. sa.raw.Feat = sa.Feature
  611. sa.raw.Mask = sa.Mask
  612. copy(sa.raw.Type[:], sa.Type)
  613. copy(sa.raw.Name[:], sa.Name)
  614. return unsafe.Pointer(&sa.raw), SizeofSockaddrALG, nil
  615. }
  616. // SockaddrVM implements the Sockaddr interface for AF_VSOCK type sockets.
  617. // SockaddrVM provides access to Linux VM sockets: a mechanism that enables
  618. // bidirectional communication between a hypervisor and its guest virtual
  619. // machines.
  620. type SockaddrVM struct {
  621. // CID and Port specify a context ID and port address for a VM socket.
  622. // Guests have a unique CID, and hosts may have a well-known CID of:
  623. // - VMADDR_CID_HYPERVISOR: refers to the hypervisor process.
  624. // - VMADDR_CID_LOCAL: refers to local communication (loopback).
  625. // - VMADDR_CID_HOST: refers to other processes on the host.
  626. CID uint32
  627. Port uint32
  628. Flags uint8
  629. raw RawSockaddrVM
  630. }
  631. func (sa *SockaddrVM) sockaddr() (unsafe.Pointer, _Socklen, error) {
  632. sa.raw.Family = AF_VSOCK
  633. sa.raw.Port = sa.Port
  634. sa.raw.Cid = sa.CID
  635. sa.raw.Flags = sa.Flags
  636. return unsafe.Pointer(&sa.raw), SizeofSockaddrVM, nil
  637. }
  638. type SockaddrXDP struct {
  639. Flags uint16
  640. Ifindex uint32
  641. QueueID uint32
  642. SharedUmemFD uint32
  643. raw RawSockaddrXDP
  644. }
  645. func (sa *SockaddrXDP) sockaddr() (unsafe.Pointer, _Socklen, error) {
  646. sa.raw.Family = AF_XDP
  647. sa.raw.Flags = sa.Flags
  648. sa.raw.Ifindex = sa.Ifindex
  649. sa.raw.Queue_id = sa.QueueID
  650. sa.raw.Shared_umem_fd = sa.SharedUmemFD
  651. return unsafe.Pointer(&sa.raw), SizeofSockaddrXDP, nil
  652. }
  653. // This constant mirrors the #define of PX_PROTO_OE in
  654. // linux/if_pppox.h. We're defining this by hand here instead of
  655. // autogenerating through mkerrors.sh because including
  656. // linux/if_pppox.h causes some declaration conflicts with other
  657. // includes (linux/if_pppox.h includes linux/in.h, which conflicts
  658. // with netinet/in.h). Given that we only need a single zero constant
  659. // out of that file, it's cleaner to just define it by hand here.
  660. const px_proto_oe = 0
  661. type SockaddrPPPoE struct {
  662. SID uint16
  663. Remote []byte
  664. Dev string
  665. raw RawSockaddrPPPoX
  666. }
  667. func (sa *SockaddrPPPoE) sockaddr() (unsafe.Pointer, _Socklen, error) {
  668. if len(sa.Remote) != 6 {
  669. return nil, 0, EINVAL
  670. }
  671. if len(sa.Dev) > IFNAMSIZ-1 {
  672. return nil, 0, EINVAL
  673. }
  674. *(*uint16)(unsafe.Pointer(&sa.raw[0])) = AF_PPPOX
  675. // This next field is in host-endian byte order. We can't use the
  676. // same unsafe pointer cast as above, because this value is not
  677. // 32-bit aligned and some architectures don't allow unaligned
  678. // access.
  679. //
  680. // However, the value of px_proto_oe is 0, so we can use
  681. // encoding/binary helpers to write the bytes without worrying
  682. // about the ordering.
  683. binary.BigEndian.PutUint32(sa.raw[2:6], px_proto_oe)
  684. // This field is deliberately big-endian, unlike the previous
  685. // one. The kernel expects SID to be in network byte order.
  686. binary.BigEndian.PutUint16(sa.raw[6:8], sa.SID)
  687. copy(sa.raw[8:14], sa.Remote)
  688. for i := 14; i < 14+IFNAMSIZ; i++ {
  689. sa.raw[i] = 0
  690. }
  691. copy(sa.raw[14:], sa.Dev)
  692. return unsafe.Pointer(&sa.raw), SizeofSockaddrPPPoX, nil
  693. }
  694. // SockaddrTIPC implements the Sockaddr interface for AF_TIPC type sockets.
  695. // For more information on TIPC, see: http://tipc.sourceforge.net/.
  696. type SockaddrTIPC struct {
  697. // Scope is the publication scopes when binding service/service range.
  698. // Should be set to TIPC_CLUSTER_SCOPE or TIPC_NODE_SCOPE.
  699. Scope int
  700. // Addr is the type of address used to manipulate a socket. Addr must be
  701. // one of:
  702. // - *TIPCSocketAddr: "id" variant in the C addr union
  703. // - *TIPCServiceRange: "nameseq" variant in the C addr union
  704. // - *TIPCServiceName: "name" variant in the C addr union
  705. //
  706. // If nil, EINVAL will be returned when the structure is used.
  707. Addr TIPCAddr
  708. raw RawSockaddrTIPC
  709. }
  710. // TIPCAddr is implemented by types that can be used as an address for
  711. // SockaddrTIPC. It is only implemented by *TIPCSocketAddr, *TIPCServiceRange,
  712. // and *TIPCServiceName.
  713. type TIPCAddr interface {
  714. tipcAddrtype() uint8
  715. tipcAddr() [12]byte
  716. }
  717. func (sa *TIPCSocketAddr) tipcAddr() [12]byte {
  718. var out [12]byte
  719. copy(out[:], (*(*[unsafe.Sizeof(TIPCSocketAddr{})]byte)(unsafe.Pointer(sa)))[:])
  720. return out
  721. }
  722. func (sa *TIPCSocketAddr) tipcAddrtype() uint8 { return TIPC_SOCKET_ADDR }
  723. func (sa *TIPCServiceRange) tipcAddr() [12]byte {
  724. var out [12]byte
  725. copy(out[:], (*(*[unsafe.Sizeof(TIPCServiceRange{})]byte)(unsafe.Pointer(sa)))[:])
  726. return out
  727. }
  728. func (sa *TIPCServiceRange) tipcAddrtype() uint8 { return TIPC_SERVICE_RANGE }
  729. func (sa *TIPCServiceName) tipcAddr() [12]byte {
  730. var out [12]byte
  731. copy(out[:], (*(*[unsafe.Sizeof(TIPCServiceName{})]byte)(unsafe.Pointer(sa)))[:])
  732. return out
  733. }
  734. func (sa *TIPCServiceName) tipcAddrtype() uint8 { return TIPC_SERVICE_ADDR }
  735. func (sa *SockaddrTIPC) sockaddr() (unsafe.Pointer, _Socklen, error) {
  736. if sa.Addr == nil {
  737. return nil, 0, EINVAL
  738. }
  739. sa.raw.Family = AF_TIPC
  740. sa.raw.Scope = int8(sa.Scope)
  741. sa.raw.Addrtype = sa.Addr.tipcAddrtype()
  742. sa.raw.Addr = sa.Addr.tipcAddr()
  743. return unsafe.Pointer(&sa.raw), SizeofSockaddrTIPC, nil
  744. }
  745. // SockaddrL2TPIP implements the Sockaddr interface for IPPROTO_L2TP/AF_INET sockets.
  746. type SockaddrL2TPIP struct {
  747. Addr [4]byte
  748. ConnId uint32
  749. raw RawSockaddrL2TPIP
  750. }
  751. func (sa *SockaddrL2TPIP) sockaddr() (unsafe.Pointer, _Socklen, error) {
  752. sa.raw.Family = AF_INET
  753. sa.raw.Conn_id = sa.ConnId
  754. sa.raw.Addr = sa.Addr
  755. return unsafe.Pointer(&sa.raw), SizeofSockaddrL2TPIP, nil
  756. }
  757. // SockaddrL2TPIP6 implements the Sockaddr interface for IPPROTO_L2TP/AF_INET6 sockets.
  758. type SockaddrL2TPIP6 struct {
  759. Addr [16]byte
  760. ZoneId uint32
  761. ConnId uint32
  762. raw RawSockaddrL2TPIP6
  763. }
  764. func (sa *SockaddrL2TPIP6) sockaddr() (unsafe.Pointer, _Socklen, error) {
  765. sa.raw.Family = AF_INET6
  766. sa.raw.Conn_id = sa.ConnId
  767. sa.raw.Scope_id = sa.ZoneId
  768. sa.raw.Addr = sa.Addr
  769. return unsafe.Pointer(&sa.raw), SizeofSockaddrL2TPIP6, nil
  770. }
  771. // SockaddrIUCV implements the Sockaddr interface for AF_IUCV sockets.
  772. type SockaddrIUCV struct {
  773. UserID string
  774. Name string
  775. raw RawSockaddrIUCV
  776. }
  777. func (sa *SockaddrIUCV) sockaddr() (unsafe.Pointer, _Socklen, error) {
  778. sa.raw.Family = AF_IUCV
  779. // These are EBCDIC encoded by the kernel, but we still need to pad them
  780. // with blanks. Initializing with blanks allows the caller to feed in either
  781. // a padded or an unpadded string.
  782. for i := 0; i < 8; i++ {
  783. sa.raw.Nodeid[i] = ' '
  784. sa.raw.User_id[i] = ' '
  785. sa.raw.Name[i] = ' '
  786. }
  787. if len(sa.UserID) > 8 || len(sa.Name) > 8 {
  788. return nil, 0, EINVAL
  789. }
  790. for i, b := range []byte(sa.UserID[:]) {
  791. sa.raw.User_id[i] = int8(b)
  792. }
  793. for i, b := range []byte(sa.Name[:]) {
  794. sa.raw.Name[i] = int8(b)
  795. }
  796. return unsafe.Pointer(&sa.raw), SizeofSockaddrIUCV, nil
  797. }
  798. type SockaddrNFC struct {
  799. DeviceIdx uint32
  800. TargetIdx uint32
  801. NFCProtocol uint32
  802. raw RawSockaddrNFC
  803. }
  804. func (sa *SockaddrNFC) sockaddr() (unsafe.Pointer, _Socklen, error) {
  805. sa.raw.Sa_family = AF_NFC
  806. sa.raw.Dev_idx = sa.DeviceIdx
  807. sa.raw.Target_idx = sa.TargetIdx
  808. sa.raw.Nfc_protocol = sa.NFCProtocol
  809. return unsafe.Pointer(&sa.raw), SizeofSockaddrNFC, nil
  810. }
  811. type SockaddrNFCLLCP struct {
  812. DeviceIdx uint32
  813. TargetIdx uint32
  814. NFCProtocol uint32
  815. DestinationSAP uint8
  816. SourceSAP uint8
  817. ServiceName string
  818. raw RawSockaddrNFCLLCP
  819. }
  820. func (sa *SockaddrNFCLLCP) sockaddr() (unsafe.Pointer, _Socklen, error) {
  821. sa.raw.Sa_family = AF_NFC
  822. sa.raw.Dev_idx = sa.DeviceIdx
  823. sa.raw.Target_idx = sa.TargetIdx
  824. sa.raw.Nfc_protocol = sa.NFCProtocol
  825. sa.raw.Dsap = sa.DestinationSAP
  826. sa.raw.Ssap = sa.SourceSAP
  827. if len(sa.ServiceName) > len(sa.raw.Service_name) {
  828. return nil, 0, EINVAL
  829. }
  830. copy(sa.raw.Service_name[:], sa.ServiceName)
  831. sa.raw.SetServiceNameLen(len(sa.ServiceName))
  832. return unsafe.Pointer(&sa.raw), SizeofSockaddrNFCLLCP, nil
  833. }
  834. var socketProtocol = func(fd int) (int, error) {
  835. return GetsockoptInt(fd, SOL_SOCKET, SO_PROTOCOL)
  836. }
  837. func anyToSockaddr(fd int, rsa *RawSockaddrAny) (Sockaddr, error) {
  838. switch rsa.Addr.Family {
  839. case AF_NETLINK:
  840. pp := (*RawSockaddrNetlink)(unsafe.Pointer(rsa))
  841. sa := new(SockaddrNetlink)
  842. sa.Family = pp.Family
  843. sa.Pad = pp.Pad
  844. sa.Pid = pp.Pid
  845. sa.Groups = pp.Groups
  846. return sa, nil
  847. case AF_PACKET:
  848. pp := (*RawSockaddrLinklayer)(unsafe.Pointer(rsa))
  849. sa := new(SockaddrLinklayer)
  850. sa.Protocol = pp.Protocol
  851. sa.Ifindex = int(pp.Ifindex)
  852. sa.Hatype = pp.Hatype
  853. sa.Pkttype = pp.Pkttype
  854. sa.Halen = pp.Halen
  855. sa.Addr = pp.Addr
  856. return sa, nil
  857. case AF_UNIX:
  858. pp := (*RawSockaddrUnix)(unsafe.Pointer(rsa))
  859. sa := new(SockaddrUnix)
  860. if pp.Path[0] == 0 {
  861. // "Abstract" Unix domain socket.
  862. // Rewrite leading NUL as @ for textual display.
  863. // (This is the standard convention.)
  864. // Not friendly to overwrite in place,
  865. // but the callers below don't care.
  866. pp.Path[0] = '@'
  867. }
  868. // Assume path ends at NUL.
  869. // This is not technically the Linux semantics for
  870. // abstract Unix domain sockets--they are supposed
  871. // to be uninterpreted fixed-size binary blobs--but
  872. // everyone uses this convention.
  873. n := 0
  874. for n < len(pp.Path) && pp.Path[n] != 0 {
  875. n++
  876. }
  877. sa.Name = string(unsafe.Slice((*byte)(unsafe.Pointer(&pp.Path[0])), n))
  878. return sa, nil
  879. case AF_INET:
  880. proto, err := socketProtocol(fd)
  881. if err != nil {
  882. return nil, err
  883. }
  884. switch proto {
  885. case IPPROTO_L2TP:
  886. pp := (*RawSockaddrL2TPIP)(unsafe.Pointer(rsa))
  887. sa := new(SockaddrL2TPIP)
  888. sa.ConnId = pp.Conn_id
  889. sa.Addr = pp.Addr
  890. return sa, nil
  891. default:
  892. pp := (*RawSockaddrInet4)(unsafe.Pointer(rsa))
  893. sa := new(SockaddrInet4)
  894. p := (*[2]byte)(unsafe.Pointer(&pp.Port))
  895. sa.Port = int(p[0])<<8 + int(p[1])
  896. sa.Addr = pp.Addr
  897. return sa, nil
  898. }
  899. case AF_INET6:
  900. proto, err := socketProtocol(fd)
  901. if err != nil {
  902. return nil, err
  903. }
  904. switch proto {
  905. case IPPROTO_L2TP:
  906. pp := (*RawSockaddrL2TPIP6)(unsafe.Pointer(rsa))
  907. sa := new(SockaddrL2TPIP6)
  908. sa.ConnId = pp.Conn_id
  909. sa.ZoneId = pp.Scope_id
  910. sa.Addr = pp.Addr
  911. return sa, nil
  912. default:
  913. pp := (*RawSockaddrInet6)(unsafe.Pointer(rsa))
  914. sa := new(SockaddrInet6)
  915. p := (*[2]byte)(unsafe.Pointer(&pp.Port))
  916. sa.Port = int(p[0])<<8 + int(p[1])
  917. sa.ZoneId = pp.Scope_id
  918. sa.Addr = pp.Addr
  919. return sa, nil
  920. }
  921. case AF_VSOCK:
  922. pp := (*RawSockaddrVM)(unsafe.Pointer(rsa))
  923. sa := &SockaddrVM{
  924. CID: pp.Cid,
  925. Port: pp.Port,
  926. Flags: pp.Flags,
  927. }
  928. return sa, nil
  929. case AF_BLUETOOTH:
  930. proto, err := socketProtocol(fd)
  931. if err != nil {
  932. return nil, err
  933. }
  934. // only BTPROTO_L2CAP and BTPROTO_RFCOMM can accept connections
  935. switch proto {
  936. case BTPROTO_L2CAP:
  937. pp := (*RawSockaddrL2)(unsafe.Pointer(rsa))
  938. sa := &SockaddrL2{
  939. PSM: pp.Psm,
  940. CID: pp.Cid,
  941. Addr: pp.Bdaddr,
  942. AddrType: pp.Bdaddr_type,
  943. }
  944. return sa, nil
  945. case BTPROTO_RFCOMM:
  946. pp := (*RawSockaddrRFCOMM)(unsafe.Pointer(rsa))
  947. sa := &SockaddrRFCOMM{
  948. Channel: pp.Channel,
  949. Addr: pp.Bdaddr,
  950. }
  951. return sa, nil
  952. }
  953. case AF_XDP:
  954. pp := (*RawSockaddrXDP)(unsafe.Pointer(rsa))
  955. sa := &SockaddrXDP{
  956. Flags: pp.Flags,
  957. Ifindex: pp.Ifindex,
  958. QueueID: pp.Queue_id,
  959. SharedUmemFD: pp.Shared_umem_fd,
  960. }
  961. return sa, nil
  962. case AF_PPPOX:
  963. pp := (*RawSockaddrPPPoX)(unsafe.Pointer(rsa))
  964. if binary.BigEndian.Uint32(pp[2:6]) != px_proto_oe {
  965. return nil, EINVAL
  966. }
  967. sa := &SockaddrPPPoE{
  968. SID: binary.BigEndian.Uint16(pp[6:8]),
  969. Remote: pp[8:14],
  970. }
  971. for i := 14; i < 14+IFNAMSIZ; i++ {
  972. if pp[i] == 0 {
  973. sa.Dev = string(pp[14:i])
  974. break
  975. }
  976. }
  977. return sa, nil
  978. case AF_TIPC:
  979. pp := (*RawSockaddrTIPC)(unsafe.Pointer(rsa))
  980. sa := &SockaddrTIPC{
  981. Scope: int(pp.Scope),
  982. }
  983. // Determine which union variant is present in pp.Addr by checking
  984. // pp.Addrtype.
  985. switch pp.Addrtype {
  986. case TIPC_SERVICE_RANGE:
  987. sa.Addr = (*TIPCServiceRange)(unsafe.Pointer(&pp.Addr))
  988. case TIPC_SERVICE_ADDR:
  989. sa.Addr = (*TIPCServiceName)(unsafe.Pointer(&pp.Addr))
  990. case TIPC_SOCKET_ADDR:
  991. sa.Addr = (*TIPCSocketAddr)(unsafe.Pointer(&pp.Addr))
  992. default:
  993. return nil, EINVAL
  994. }
  995. return sa, nil
  996. case AF_IUCV:
  997. pp := (*RawSockaddrIUCV)(unsafe.Pointer(rsa))
  998. var user [8]byte
  999. var name [8]byte
  1000. for i := 0; i < 8; i++ {
  1001. user[i] = byte(pp.User_id[i])
  1002. name[i] = byte(pp.Name[i])
  1003. }
  1004. sa := &SockaddrIUCV{
  1005. UserID: string(user[:]),
  1006. Name: string(name[:]),
  1007. }
  1008. return sa, nil
  1009. case AF_CAN:
  1010. proto, err := socketProtocol(fd)
  1011. if err != nil {
  1012. return nil, err
  1013. }
  1014. pp := (*RawSockaddrCAN)(unsafe.Pointer(rsa))
  1015. switch proto {
  1016. case CAN_J1939:
  1017. sa := &SockaddrCANJ1939{
  1018. Ifindex: int(pp.Ifindex),
  1019. }
  1020. name := (*[8]byte)(unsafe.Pointer(&sa.Name))
  1021. for i := 0; i < 8; i++ {
  1022. name[i] = pp.Addr[i]
  1023. }
  1024. pgn := (*[4]byte)(unsafe.Pointer(&sa.PGN))
  1025. for i := 0; i < 4; i++ {
  1026. pgn[i] = pp.Addr[i+8]
  1027. }
  1028. addr := (*[1]byte)(unsafe.Pointer(&sa.Addr))
  1029. addr[0] = pp.Addr[12]
  1030. return sa, nil
  1031. default:
  1032. sa := &SockaddrCAN{
  1033. Ifindex: int(pp.Ifindex),
  1034. }
  1035. rx := (*[4]byte)(unsafe.Pointer(&sa.RxID))
  1036. for i := 0; i < 4; i++ {
  1037. rx[i] = pp.Addr[i]
  1038. }
  1039. tx := (*[4]byte)(unsafe.Pointer(&sa.TxID))
  1040. for i := 0; i < 4; i++ {
  1041. tx[i] = pp.Addr[i+4]
  1042. }
  1043. return sa, nil
  1044. }
  1045. case AF_NFC:
  1046. proto, err := socketProtocol(fd)
  1047. if err != nil {
  1048. return nil, err
  1049. }
  1050. switch proto {
  1051. case NFC_SOCKPROTO_RAW:
  1052. pp := (*RawSockaddrNFC)(unsafe.Pointer(rsa))
  1053. sa := &SockaddrNFC{
  1054. DeviceIdx: pp.Dev_idx,
  1055. TargetIdx: pp.Target_idx,
  1056. NFCProtocol: pp.Nfc_protocol,
  1057. }
  1058. return sa, nil
  1059. case NFC_SOCKPROTO_LLCP:
  1060. pp := (*RawSockaddrNFCLLCP)(unsafe.Pointer(rsa))
  1061. if uint64(pp.Service_name_len) > uint64(len(pp.Service_name)) {
  1062. return nil, EINVAL
  1063. }
  1064. sa := &SockaddrNFCLLCP{
  1065. DeviceIdx: pp.Dev_idx,
  1066. TargetIdx: pp.Target_idx,
  1067. NFCProtocol: pp.Nfc_protocol,
  1068. DestinationSAP: pp.Dsap,
  1069. SourceSAP: pp.Ssap,
  1070. ServiceName: string(pp.Service_name[:pp.Service_name_len]),
  1071. }
  1072. return sa, nil
  1073. default:
  1074. return nil, EINVAL
  1075. }
  1076. }
  1077. return nil, EAFNOSUPPORT
  1078. }
  1079. func Accept(fd int) (nfd int, sa Sockaddr, err error) {
  1080. var rsa RawSockaddrAny
  1081. var len _Socklen = SizeofSockaddrAny
  1082. nfd, err = accept4(fd, &rsa, &len, 0)
  1083. if err != nil {
  1084. return
  1085. }
  1086. sa, err = anyToSockaddr(fd, &rsa)
  1087. if err != nil {
  1088. Close(nfd)
  1089. nfd = 0
  1090. }
  1091. return
  1092. }
  1093. func Accept4(fd int, flags int) (nfd int, sa Sockaddr, err error) {
  1094. var rsa RawSockaddrAny
  1095. var len _Socklen = SizeofSockaddrAny
  1096. nfd, err = accept4(fd, &rsa, &len, flags)
  1097. if err != nil {
  1098. return
  1099. }
  1100. if len > SizeofSockaddrAny {
  1101. panic("RawSockaddrAny too small")
  1102. }
  1103. sa, err = anyToSockaddr(fd, &rsa)
  1104. if err != nil {
  1105. Close(nfd)
  1106. nfd = 0
  1107. }
  1108. return
  1109. }
  1110. func Getsockname(fd int) (sa Sockaddr, err error) {
  1111. var rsa RawSockaddrAny
  1112. var len _Socklen = SizeofSockaddrAny
  1113. if err = getsockname(fd, &rsa, &len); err != nil {
  1114. return
  1115. }
  1116. return anyToSockaddr(fd, &rsa)
  1117. }
  1118. func GetsockoptIPMreqn(fd, level, opt int) (*IPMreqn, error) {
  1119. var value IPMreqn
  1120. vallen := _Socklen(SizeofIPMreqn)
  1121. err := getsockopt(fd, level, opt, unsafe.Pointer(&value), &vallen)
  1122. return &value, err
  1123. }
  1124. func GetsockoptUcred(fd, level, opt int) (*Ucred, error) {
  1125. var value Ucred
  1126. vallen := _Socklen(SizeofUcred)
  1127. err := getsockopt(fd, level, opt, unsafe.Pointer(&value), &vallen)
  1128. return &value, err
  1129. }
  1130. func GetsockoptTCPInfo(fd, level, opt int) (*TCPInfo, error) {
  1131. var value TCPInfo
  1132. vallen := _Socklen(SizeofTCPInfo)
  1133. err := getsockopt(fd, level, opt, unsafe.Pointer(&value), &vallen)
  1134. return &value, err
  1135. }
  1136. // GetsockoptString returns the string value of the socket option opt for the
  1137. // socket associated with fd at the given socket level.
  1138. func GetsockoptString(fd, level, opt int) (string, error) {
  1139. buf := make([]byte, 256)
  1140. vallen := _Socklen(len(buf))
  1141. err := getsockopt(fd, level, opt, unsafe.Pointer(&buf[0]), &vallen)
  1142. if err != nil {
  1143. if err == ERANGE {
  1144. buf = make([]byte, vallen)
  1145. err = getsockopt(fd, level, opt, unsafe.Pointer(&buf[0]), &vallen)
  1146. }
  1147. if err != nil {
  1148. return "", err
  1149. }
  1150. }
  1151. return string(buf[:vallen-1]), nil
  1152. }
  1153. func GetsockoptTpacketStats(fd, level, opt int) (*TpacketStats, error) {
  1154. var value TpacketStats
  1155. vallen := _Socklen(SizeofTpacketStats)
  1156. err := getsockopt(fd, level, opt, unsafe.Pointer(&value), &vallen)
  1157. return &value, err
  1158. }
  1159. func GetsockoptTpacketStatsV3(fd, level, opt int) (*TpacketStatsV3, error) {
  1160. var value TpacketStatsV3
  1161. vallen := _Socklen(SizeofTpacketStatsV3)
  1162. err := getsockopt(fd, level, opt, unsafe.Pointer(&value), &vallen)
  1163. return &value, err
  1164. }
  1165. func SetsockoptIPMreqn(fd, level, opt int, mreq *IPMreqn) (err error) {
  1166. return setsockopt(fd, level, opt, unsafe.Pointer(mreq), unsafe.Sizeof(*mreq))
  1167. }
  1168. func SetsockoptPacketMreq(fd, level, opt int, mreq *PacketMreq) error {
  1169. return setsockopt(fd, level, opt, unsafe.Pointer(mreq), unsafe.Sizeof(*mreq))
  1170. }
  1171. // SetsockoptSockFprog attaches a classic BPF or an extended BPF program to a
  1172. // socket to filter incoming packets. See 'man 7 socket' for usage information.
  1173. func SetsockoptSockFprog(fd, level, opt int, fprog *SockFprog) error {
  1174. return setsockopt(fd, level, opt, unsafe.Pointer(fprog), unsafe.Sizeof(*fprog))
  1175. }
  1176. func SetsockoptCanRawFilter(fd, level, opt int, filter []CanFilter) error {
  1177. var p unsafe.Pointer
  1178. if len(filter) > 0 {
  1179. p = unsafe.Pointer(&filter[0])
  1180. }
  1181. return setsockopt(fd, level, opt, p, uintptr(len(filter)*SizeofCanFilter))
  1182. }
  1183. func SetsockoptTpacketReq(fd, level, opt int, tp *TpacketReq) error {
  1184. return setsockopt(fd, level, opt, unsafe.Pointer(tp), unsafe.Sizeof(*tp))
  1185. }
  1186. func SetsockoptTpacketReq3(fd, level, opt int, tp *TpacketReq3) error {
  1187. return setsockopt(fd, level, opt, unsafe.Pointer(tp), unsafe.Sizeof(*tp))
  1188. }
  1189. func SetsockoptTCPRepairOpt(fd, level, opt int, o []TCPRepairOpt) (err error) {
  1190. if len(o) == 0 {
  1191. return EINVAL
  1192. }
  1193. return setsockopt(fd, level, opt, unsafe.Pointer(&o[0]), uintptr(SizeofTCPRepairOpt*len(o)))
  1194. }
  1195. func SetsockoptTCPMD5Sig(fd, level, opt int, s *TCPMD5Sig) error {
  1196. return setsockopt(fd, level, opt, unsafe.Pointer(s), unsafe.Sizeof(*s))
  1197. }
  1198. // Keyctl Commands (http://man7.org/linux/man-pages/man2/keyctl.2.html)
  1199. // KeyctlInt calls keyctl commands in which each argument is an int.
  1200. // These commands are KEYCTL_REVOKE, KEYCTL_CHOWN, KEYCTL_CLEAR, KEYCTL_LINK,
  1201. // KEYCTL_UNLINK, KEYCTL_NEGATE, KEYCTL_SET_REQKEY_KEYRING, KEYCTL_SET_TIMEOUT,
  1202. // KEYCTL_ASSUME_AUTHORITY, KEYCTL_SESSION_TO_PARENT, KEYCTL_REJECT,
  1203. // KEYCTL_INVALIDATE, and KEYCTL_GET_PERSISTENT.
  1204. //sys KeyctlInt(cmd int, arg2 int, arg3 int, arg4 int, arg5 int) (ret int, err error) = SYS_KEYCTL
  1205. // KeyctlBuffer calls keyctl commands in which the third and fourth
  1206. // arguments are a buffer and its length, respectively.
  1207. // These commands are KEYCTL_UPDATE, KEYCTL_READ, and KEYCTL_INSTANTIATE.
  1208. //sys KeyctlBuffer(cmd int, arg2 int, buf []byte, arg5 int) (ret int, err error) = SYS_KEYCTL
  1209. // KeyctlString calls keyctl commands which return a string.
  1210. // These commands are KEYCTL_DESCRIBE and KEYCTL_GET_SECURITY.
  1211. func KeyctlString(cmd int, id int) (string, error) {
  1212. // We must loop as the string data may change in between the syscalls.
  1213. // We could allocate a large buffer here to reduce the chance that the
  1214. // syscall needs to be called twice; however, this is unnecessary as
  1215. // the performance loss is negligible.
  1216. var buffer []byte
  1217. for {
  1218. // Try to fill the buffer with data
  1219. length, err := KeyctlBuffer(cmd, id, buffer, 0)
  1220. if err != nil {
  1221. return "", err
  1222. }
  1223. // Check if the data was written
  1224. if length <= len(buffer) {
  1225. // Exclude the null terminator
  1226. return string(buffer[:length-1]), nil
  1227. }
  1228. // Make a bigger buffer if needed
  1229. buffer = make([]byte, length)
  1230. }
  1231. }
  1232. // Keyctl commands with special signatures.
  1233. // KeyctlGetKeyringID implements the KEYCTL_GET_KEYRING_ID command.
  1234. // See the full documentation at:
  1235. // http://man7.org/linux/man-pages/man3/keyctl_get_keyring_ID.3.html
  1236. func KeyctlGetKeyringID(id int, create bool) (ringid int, err error) {
  1237. createInt := 0
  1238. if create {
  1239. createInt = 1
  1240. }
  1241. return KeyctlInt(KEYCTL_GET_KEYRING_ID, id, createInt, 0, 0)
  1242. }
  1243. // KeyctlSetperm implements the KEYCTL_SETPERM command. The perm value is the
  1244. // key handle permission mask as described in the "keyctl setperm" section of
  1245. // http://man7.org/linux/man-pages/man1/keyctl.1.html.
  1246. // See the full documentation at:
  1247. // http://man7.org/linux/man-pages/man3/keyctl_setperm.3.html
  1248. func KeyctlSetperm(id int, perm uint32) error {
  1249. _, err := KeyctlInt(KEYCTL_SETPERM, id, int(perm), 0, 0)
  1250. return err
  1251. }
  1252. //sys keyctlJoin(cmd int, arg2 string) (ret int, err error) = SYS_KEYCTL
  1253. // KeyctlJoinSessionKeyring implements the KEYCTL_JOIN_SESSION_KEYRING command.
  1254. // See the full documentation at:
  1255. // http://man7.org/linux/man-pages/man3/keyctl_join_session_keyring.3.html
  1256. func KeyctlJoinSessionKeyring(name string) (ringid int, err error) {
  1257. return keyctlJoin(KEYCTL_JOIN_SESSION_KEYRING, name)
  1258. }
  1259. //sys keyctlSearch(cmd int, arg2 int, arg3 string, arg4 string, arg5 int) (ret int, err error) = SYS_KEYCTL
  1260. // KeyctlSearch implements the KEYCTL_SEARCH command.
  1261. // See the full documentation at:
  1262. // http://man7.org/linux/man-pages/man3/keyctl_search.3.html
  1263. func KeyctlSearch(ringid int, keyType, description string, destRingid int) (id int, err error) {
  1264. return keyctlSearch(KEYCTL_SEARCH, ringid, keyType, description, destRingid)
  1265. }
  1266. //sys keyctlIOV(cmd int, arg2 int, payload []Iovec, arg5 int) (err error) = SYS_KEYCTL
  1267. // KeyctlInstantiateIOV implements the KEYCTL_INSTANTIATE_IOV command. This
  1268. // command is similar to KEYCTL_INSTANTIATE, except that the payload is a slice
  1269. // of Iovec (each of which represents a buffer) instead of a single buffer.
  1270. // See the full documentation at:
  1271. // http://man7.org/linux/man-pages/man3/keyctl_instantiate_iov.3.html
  1272. func KeyctlInstantiateIOV(id int, payload []Iovec, ringid int) error {
  1273. return keyctlIOV(KEYCTL_INSTANTIATE_IOV, id, payload, ringid)
  1274. }
  1275. //sys keyctlDH(cmd int, arg2 *KeyctlDHParams, buf []byte) (ret int, err error) = SYS_KEYCTL
  1276. // KeyctlDHCompute implements the KEYCTL_DH_COMPUTE command. This command
  1277. // computes a Diffie-Hellman shared secret based on the provide params. The
  1278. // secret is written to the provided buffer and the returned size is the number
  1279. // of bytes written (returning an error if there is insufficient space in the
  1280. // buffer). If a nil buffer is passed in, this function returns the minimum
  1281. // buffer length needed to store the appropriate data. Note that this differs
  1282. // from KEYCTL_READ's behavior which always returns the requested payload size.
  1283. // See the full documentation at:
  1284. // http://man7.org/linux/man-pages/man3/keyctl_dh_compute.3.html
  1285. func KeyctlDHCompute(params *KeyctlDHParams, buffer []byte) (size int, err error) {
  1286. return keyctlDH(KEYCTL_DH_COMPUTE, params, buffer)
  1287. }
  1288. // KeyctlRestrictKeyring implements the KEYCTL_RESTRICT_KEYRING command. This
  1289. // command limits the set of keys that can be linked to the keyring, regardless
  1290. // of keyring permissions. The command requires the "setattr" permission.
  1291. //
  1292. // When called with an empty keyType the command locks the keyring, preventing
  1293. // any further keys from being linked to the keyring.
  1294. //
  1295. // The "asymmetric" keyType defines restrictions requiring key payloads to be
  1296. // DER encoded X.509 certificates signed by keys in another keyring. Restrictions
  1297. // for "asymmetric" include "builtin_trusted", "builtin_and_secondary_trusted",
  1298. // "key_or_keyring:<key>", and "key_or_keyring:<key>:chain".
  1299. //
  1300. // As of Linux 4.12, only the "asymmetric" keyType defines type-specific
  1301. // restrictions.
  1302. //
  1303. // See the full documentation at:
  1304. // http://man7.org/linux/man-pages/man3/keyctl_restrict_keyring.3.html
  1305. // http://man7.org/linux/man-pages/man2/keyctl.2.html
  1306. func KeyctlRestrictKeyring(ringid int, keyType string, restriction string) error {
  1307. if keyType == "" {
  1308. return keyctlRestrictKeyring(KEYCTL_RESTRICT_KEYRING, ringid)
  1309. }
  1310. return keyctlRestrictKeyringByType(KEYCTL_RESTRICT_KEYRING, ringid, keyType, restriction)
  1311. }
  1312. //sys keyctlRestrictKeyringByType(cmd int, arg2 int, keyType string, restriction string) (err error) = SYS_KEYCTL
  1313. //sys keyctlRestrictKeyring(cmd int, arg2 int) (err error) = SYS_KEYCTL
  1314. func recvmsgRaw(fd int, iov []Iovec, oob []byte, flags int, rsa *RawSockaddrAny) (n, oobn int, recvflags int, err error) {
  1315. var msg Msghdr
  1316. msg.Name = (*byte)(unsafe.Pointer(rsa))
  1317. msg.Namelen = uint32(SizeofSockaddrAny)
  1318. var dummy byte
  1319. if len(oob) > 0 {
  1320. if emptyIovecs(iov) {
  1321. var sockType int
  1322. sockType, err = GetsockoptInt(fd, SOL_SOCKET, SO_TYPE)
  1323. if err != nil {
  1324. return
  1325. }
  1326. // receive at least one normal byte
  1327. if sockType != SOCK_DGRAM {
  1328. var iova [1]Iovec
  1329. iova[0].Base = &dummy
  1330. iova[0].SetLen(1)
  1331. iov = iova[:]
  1332. }
  1333. }
  1334. msg.Control = &oob[0]
  1335. msg.SetControllen(len(oob))
  1336. }
  1337. if len(iov) > 0 {
  1338. msg.Iov = &iov[0]
  1339. msg.SetIovlen(len(iov))
  1340. }
  1341. if n, err = recvmsg(fd, &msg, flags); err != nil {
  1342. return
  1343. }
  1344. oobn = int(msg.Controllen)
  1345. recvflags = int(msg.Flags)
  1346. return
  1347. }
  1348. func sendmsgN(fd int, iov []Iovec, oob []byte, ptr unsafe.Pointer, salen _Socklen, flags int) (n int, err error) {
  1349. var msg Msghdr
  1350. msg.Name = (*byte)(ptr)
  1351. msg.Namelen = uint32(salen)
  1352. var dummy byte
  1353. var empty bool
  1354. if len(oob) > 0 {
  1355. empty = emptyIovecs(iov)
  1356. if empty {
  1357. var sockType int
  1358. sockType, err = GetsockoptInt(fd, SOL_SOCKET, SO_TYPE)
  1359. if err != nil {
  1360. return 0, err
  1361. }
  1362. // send at least one normal byte
  1363. if sockType != SOCK_DGRAM {
  1364. var iova [1]Iovec
  1365. iova[0].Base = &dummy
  1366. iova[0].SetLen(1)
  1367. iov = iova[:]
  1368. }
  1369. }
  1370. msg.Control = &oob[0]
  1371. msg.SetControllen(len(oob))
  1372. }
  1373. if len(iov) > 0 {
  1374. msg.Iov = &iov[0]
  1375. msg.SetIovlen(len(iov))
  1376. }
  1377. if n, err = sendmsg(fd, &msg, flags); err != nil {
  1378. return 0, err
  1379. }
  1380. if len(oob) > 0 && empty {
  1381. n = 0
  1382. }
  1383. return n, nil
  1384. }
  1385. // BindToDevice binds the socket associated with fd to device.
  1386. func BindToDevice(fd int, device string) (err error) {
  1387. return SetsockoptString(fd, SOL_SOCKET, SO_BINDTODEVICE, device)
  1388. }
  1389. //sys ptrace(request int, pid int, addr uintptr, data uintptr) (err error)
  1390. //sys ptracePtr(request int, pid int, addr uintptr, data unsafe.Pointer) (err error) = SYS_PTRACE
  1391. func ptracePeek(req int, pid int, addr uintptr, out []byte) (count int, err error) {
  1392. // The peek requests are machine-size oriented, so we wrap it
  1393. // to retrieve arbitrary-length data.
  1394. // The ptrace syscall differs from glibc's ptrace.
  1395. // Peeks returns the word in *data, not as the return value.
  1396. var buf [SizeofPtr]byte
  1397. // Leading edge. PEEKTEXT/PEEKDATA don't require aligned
  1398. // access (PEEKUSER warns that it might), but if we don't
  1399. // align our reads, we might straddle an unmapped page
  1400. // boundary and not get the bytes leading up to the page
  1401. // boundary.
  1402. n := 0
  1403. if addr%SizeofPtr != 0 {
  1404. err = ptracePtr(req, pid, addr-addr%SizeofPtr, unsafe.Pointer(&buf[0]))
  1405. if err != nil {
  1406. return 0, err
  1407. }
  1408. n += copy(out, buf[addr%SizeofPtr:])
  1409. out = out[n:]
  1410. }
  1411. // Remainder.
  1412. for len(out) > 0 {
  1413. // We use an internal buffer to guarantee alignment.
  1414. // It's not documented if this is necessary, but we're paranoid.
  1415. err = ptracePtr(req, pid, addr+uintptr(n), unsafe.Pointer(&buf[0]))
  1416. if err != nil {
  1417. return n, err
  1418. }
  1419. copied := copy(out, buf[0:])
  1420. n += copied
  1421. out = out[copied:]
  1422. }
  1423. return n, nil
  1424. }
  1425. func PtracePeekText(pid int, addr uintptr, out []byte) (count int, err error) {
  1426. return ptracePeek(PTRACE_PEEKTEXT, pid, addr, out)
  1427. }
  1428. func PtracePeekData(pid int, addr uintptr, out []byte) (count int, err error) {
  1429. return ptracePeek(PTRACE_PEEKDATA, pid, addr, out)
  1430. }
  1431. func PtracePeekUser(pid int, addr uintptr, out []byte) (count int, err error) {
  1432. return ptracePeek(PTRACE_PEEKUSR, pid, addr, out)
  1433. }
  1434. func ptracePoke(pokeReq int, peekReq int, pid int, addr uintptr, data []byte) (count int, err error) {
  1435. // As for ptracePeek, we need to align our accesses to deal
  1436. // with the possibility of straddling an invalid page.
  1437. // Leading edge.
  1438. n := 0
  1439. if addr%SizeofPtr != 0 {
  1440. var buf [SizeofPtr]byte
  1441. err = ptracePtr(peekReq, pid, addr-addr%SizeofPtr, unsafe.Pointer(&buf[0]))
  1442. if err != nil {
  1443. return 0, err
  1444. }
  1445. n += copy(buf[addr%SizeofPtr:], data)
  1446. word := *((*uintptr)(unsafe.Pointer(&buf[0])))
  1447. err = ptrace(pokeReq, pid, addr-addr%SizeofPtr, word)
  1448. if err != nil {
  1449. return 0, err
  1450. }
  1451. data = data[n:]
  1452. }
  1453. // Interior.
  1454. for len(data) > SizeofPtr {
  1455. word := *((*uintptr)(unsafe.Pointer(&data[0])))
  1456. err = ptrace(pokeReq, pid, addr+uintptr(n), word)
  1457. if err != nil {
  1458. return n, err
  1459. }
  1460. n += SizeofPtr
  1461. data = data[SizeofPtr:]
  1462. }
  1463. // Trailing edge.
  1464. if len(data) > 0 {
  1465. var buf [SizeofPtr]byte
  1466. err = ptracePtr(peekReq, pid, addr+uintptr(n), unsafe.Pointer(&buf[0]))
  1467. if err != nil {
  1468. return n, err
  1469. }
  1470. copy(buf[0:], data)
  1471. word := *((*uintptr)(unsafe.Pointer(&buf[0])))
  1472. err = ptrace(pokeReq, pid, addr+uintptr(n), word)
  1473. if err != nil {
  1474. return n, err
  1475. }
  1476. n += len(data)
  1477. }
  1478. return n, nil
  1479. }
  1480. func PtracePokeText(pid int, addr uintptr, data []byte) (count int, err error) {
  1481. return ptracePoke(PTRACE_POKETEXT, PTRACE_PEEKTEXT, pid, addr, data)
  1482. }
  1483. func PtracePokeData(pid int, addr uintptr, data []byte) (count int, err error) {
  1484. return ptracePoke(PTRACE_POKEDATA, PTRACE_PEEKDATA, pid, addr, data)
  1485. }
  1486. func PtracePokeUser(pid int, addr uintptr, data []byte) (count int, err error) {
  1487. return ptracePoke(PTRACE_POKEUSR, PTRACE_PEEKUSR, pid, addr, data)
  1488. }
  1489. // elfNT_PRSTATUS is a copy of the debug/elf.NT_PRSTATUS constant so
  1490. // x/sys/unix doesn't need to depend on debug/elf and thus
  1491. // compress/zlib, debug/dwarf, and other packages.
  1492. const elfNT_PRSTATUS = 1
  1493. func PtraceGetRegs(pid int, regsout *PtraceRegs) (err error) {
  1494. var iov Iovec
  1495. iov.Base = (*byte)(unsafe.Pointer(regsout))
  1496. iov.SetLen(int(unsafe.Sizeof(*regsout)))
  1497. return ptracePtr(PTRACE_GETREGSET, pid, uintptr(elfNT_PRSTATUS), unsafe.Pointer(&iov))
  1498. }
  1499. func PtraceSetRegs(pid int, regs *PtraceRegs) (err error) {
  1500. var iov Iovec
  1501. iov.Base = (*byte)(unsafe.Pointer(regs))
  1502. iov.SetLen(int(unsafe.Sizeof(*regs)))
  1503. return ptracePtr(PTRACE_SETREGSET, pid, uintptr(elfNT_PRSTATUS), unsafe.Pointer(&iov))
  1504. }
  1505. func PtraceSetOptions(pid int, options int) (err error) {
  1506. return ptrace(PTRACE_SETOPTIONS, pid, 0, uintptr(options))
  1507. }
  1508. func PtraceGetEventMsg(pid int) (msg uint, err error) {
  1509. var data _C_long
  1510. err = ptracePtr(PTRACE_GETEVENTMSG, pid, 0, unsafe.Pointer(&data))
  1511. msg = uint(data)
  1512. return
  1513. }
  1514. func PtraceCont(pid int, signal int) (err error) {
  1515. return ptrace(PTRACE_CONT, pid, 0, uintptr(signal))
  1516. }
  1517. func PtraceSyscall(pid int, signal int) (err error) {
  1518. return ptrace(PTRACE_SYSCALL, pid, 0, uintptr(signal))
  1519. }
  1520. func PtraceSingleStep(pid int) (err error) { return ptrace(PTRACE_SINGLESTEP, pid, 0, 0) }
  1521. func PtraceInterrupt(pid int) (err error) { return ptrace(PTRACE_INTERRUPT, pid, 0, 0) }
  1522. func PtraceAttach(pid int) (err error) { return ptrace(PTRACE_ATTACH, pid, 0, 0) }
  1523. func PtraceSeize(pid int) (err error) { return ptrace(PTRACE_SEIZE, pid, 0, 0) }
  1524. func PtraceDetach(pid int) (err error) { return ptrace(PTRACE_DETACH, pid, 0, 0) }
  1525. //sys reboot(magic1 uint, magic2 uint, cmd int, arg string) (err error)
  1526. func Reboot(cmd int) (err error) {
  1527. return reboot(LINUX_REBOOT_MAGIC1, LINUX_REBOOT_MAGIC2, cmd, "")
  1528. }
  1529. func direntIno(buf []byte) (uint64, bool) {
  1530. return readInt(buf, unsafe.Offsetof(Dirent{}.Ino), unsafe.Sizeof(Dirent{}.Ino))
  1531. }
  1532. func direntReclen(buf []byte) (uint64, bool) {
  1533. return readInt(buf, unsafe.Offsetof(Dirent{}.Reclen), unsafe.Sizeof(Dirent{}.Reclen))
  1534. }
  1535. func direntNamlen(buf []byte) (uint64, bool) {
  1536. reclen, ok := direntReclen(buf)
  1537. if !ok {
  1538. return 0, false
  1539. }
  1540. return reclen - uint64(unsafe.Offsetof(Dirent{}.Name)), true
  1541. }
  1542. //sys mount(source string, target string, fstype string, flags uintptr, data *byte) (err error)
  1543. func Mount(source string, target string, fstype string, flags uintptr, data string) (err error) {
  1544. // Certain file systems get rather angry and EINVAL if you give
  1545. // them an empty string of data, rather than NULL.
  1546. if data == "" {
  1547. return mount(source, target, fstype, flags, nil)
  1548. }
  1549. datap, err := BytePtrFromString(data)
  1550. if err != nil {
  1551. return err
  1552. }
  1553. return mount(source, target, fstype, flags, datap)
  1554. }
  1555. //sys mountSetattr(dirfd int, pathname string, flags uint, attr *MountAttr, size uintptr) (err error) = SYS_MOUNT_SETATTR
  1556. // MountSetattr is a wrapper for mount_setattr(2).
  1557. // https://man7.org/linux/man-pages/man2/mount_setattr.2.html
  1558. //
  1559. // Requires kernel >= 5.12.
  1560. func MountSetattr(dirfd int, pathname string, flags uint, attr *MountAttr) error {
  1561. return mountSetattr(dirfd, pathname, flags, attr, unsafe.Sizeof(*attr))
  1562. }
  1563. func Sendfile(outfd int, infd int, offset *int64, count int) (written int, err error) {
  1564. if raceenabled {
  1565. raceReleaseMerge(unsafe.Pointer(&ioSync))
  1566. }
  1567. return sendfile(outfd, infd, offset, count)
  1568. }
  1569. // Sendto
  1570. // Recvfrom
  1571. // Socketpair
  1572. /*
  1573. * Direct access
  1574. */
  1575. //sys Acct(path string) (err error)
  1576. //sys AddKey(keyType string, description string, payload []byte, ringid int) (id int, err error)
  1577. //sys Adjtimex(buf *Timex) (state int, err error)
  1578. //sysnb Capget(hdr *CapUserHeader, data *CapUserData) (err error)
  1579. //sysnb Capset(hdr *CapUserHeader, data *CapUserData) (err error)
  1580. //sys Chdir(path string) (err error)
  1581. //sys Chroot(path string) (err error)
  1582. //sys ClockAdjtime(clockid int32, buf *Timex) (state int, err error)
  1583. //sys ClockGetres(clockid int32, res *Timespec) (err error)
  1584. //sys ClockGettime(clockid int32, time *Timespec) (err error)
  1585. //sys ClockNanosleep(clockid int32, flags int, request *Timespec, remain *Timespec) (err error)
  1586. //sys Close(fd int) (err error)
  1587. //sys CloseRange(first uint, last uint, flags uint) (err error)
  1588. //sys CopyFileRange(rfd int, roff *int64, wfd int, woff *int64, len int, flags int) (n int, err error)
  1589. //sys DeleteModule(name string, flags int) (err error)
  1590. //sys Dup(oldfd int) (fd int, err error)
  1591. func Dup2(oldfd, newfd int) error {
  1592. return Dup3(oldfd, newfd, 0)
  1593. }
  1594. //sys Dup3(oldfd int, newfd int, flags int) (err error)
  1595. //sysnb EpollCreate1(flag int) (fd int, err error)
  1596. //sysnb EpollCtl(epfd int, op int, fd int, event *EpollEvent) (err error)
  1597. //sys Eventfd(initval uint, flags int) (fd int, err error) = SYS_EVENTFD2
  1598. //sys Exit(code int) = SYS_EXIT_GROUP
  1599. //sys Fallocate(fd int, mode uint32, off int64, len int64) (err error)
  1600. //sys Fchdir(fd int) (err error)
  1601. //sys Fchmod(fd int, mode uint32) (err error)
  1602. //sys Fchownat(dirfd int, path string, uid int, gid int, flags int) (err error)
  1603. //sys Fdatasync(fd int) (err error)
  1604. //sys Fgetxattr(fd int, attr string, dest []byte) (sz int, err error)
  1605. //sys FinitModule(fd int, params string, flags int) (err error)
  1606. //sys Flistxattr(fd int, dest []byte) (sz int, err error)
  1607. //sys Flock(fd int, how int) (err error)
  1608. //sys Fremovexattr(fd int, attr string) (err error)
  1609. //sys Fsetxattr(fd int, attr string, dest []byte, flags int) (err error)
  1610. //sys Fsync(fd int) (err error)
  1611. //sys Fsmount(fd int, flags int, mountAttrs int) (fsfd int, err error)
  1612. //sys Fsopen(fsName string, flags int) (fd int, err error)
  1613. //sys Fspick(dirfd int, pathName string, flags int) (fd int, err error)
  1614. //sys Getdents(fd int, buf []byte) (n int, err error) = SYS_GETDENTS64
  1615. //sysnb Getpgid(pid int) (pgid int, err error)
  1616. func Getpgrp() (pid int) {
  1617. pid, _ = Getpgid(0)
  1618. return
  1619. }
  1620. //sysnb Getpid() (pid int)
  1621. //sysnb Getppid() (ppid int)
  1622. //sys Getpriority(which int, who int) (prio int, err error)
  1623. //sys Getrandom(buf []byte, flags int) (n int, err error)
  1624. //sysnb Getrusage(who int, rusage *Rusage) (err error)
  1625. //sysnb Getsid(pid int) (sid int, err error)
  1626. //sysnb Gettid() (tid int)
  1627. //sys Getxattr(path string, attr string, dest []byte) (sz int, err error)
  1628. //sys InitModule(moduleImage []byte, params string) (err error)
  1629. //sys InotifyAddWatch(fd int, pathname string, mask uint32) (watchdesc int, err error)
  1630. //sysnb InotifyInit1(flags int) (fd int, err error)
  1631. //sysnb InotifyRmWatch(fd int, watchdesc uint32) (success int, err error)
  1632. //sysnb Kill(pid int, sig syscall.Signal) (err error)
  1633. //sys Klogctl(typ int, buf []byte) (n int, err error) = SYS_SYSLOG
  1634. //sys Lgetxattr(path string, attr string, dest []byte) (sz int, err error)
  1635. //sys Listxattr(path string, dest []byte) (sz int, err error)
  1636. //sys Llistxattr(path string, dest []byte) (sz int, err error)
  1637. //sys Lremovexattr(path string, attr string) (err error)
  1638. //sys Lsetxattr(path string, attr string, data []byte, flags int) (err error)
  1639. //sys MemfdCreate(name string, flags int) (fd int, err error)
  1640. //sys Mkdirat(dirfd int, path string, mode uint32) (err error)
  1641. //sys Mknodat(dirfd int, path string, mode uint32, dev int) (err error)
  1642. //sys MoveMount(fromDirfd int, fromPathName string, toDirfd int, toPathName string, flags int) (err error)
  1643. //sys Nanosleep(time *Timespec, leftover *Timespec) (err error)
  1644. //sys OpenTree(dfd int, fileName string, flags uint) (r int, err error)
  1645. //sys PerfEventOpen(attr *PerfEventAttr, pid int, cpu int, groupFd int, flags int) (fd int, err error)
  1646. //sys PivotRoot(newroot string, putold string) (err error) = SYS_PIVOT_ROOT
  1647. //sys Prctl(option int, arg2 uintptr, arg3 uintptr, arg4 uintptr, arg5 uintptr) (err error)
  1648. //sys pselect6(nfd int, r *FdSet, w *FdSet, e *FdSet, timeout *Timespec, sigmask *sigset_argpack) (n int, err error)
  1649. //sys read(fd int, p []byte) (n int, err error)
  1650. //sys Removexattr(path string, attr string) (err error)
  1651. //sys Renameat2(olddirfd int, oldpath string, newdirfd int, newpath string, flags uint) (err error)
  1652. //sys RequestKey(keyType string, description string, callback string, destRingid int) (id int, err error)
  1653. //sys Setdomainname(p []byte) (err error)
  1654. //sys Sethostname(p []byte) (err error)
  1655. //sysnb Setpgid(pid int, pgid int) (err error)
  1656. //sysnb Setsid() (pid int, err error)
  1657. //sysnb Settimeofday(tv *Timeval) (err error)
  1658. //sys Setns(fd int, nstype int) (err error)
  1659. //go:linkname syscall_prlimit syscall.prlimit
  1660. func syscall_prlimit(pid, resource int, newlimit, old *syscall.Rlimit) error
  1661. func Prlimit(pid, resource int, newlimit, old *Rlimit) error {
  1662. // Just call the syscall version, because as of Go 1.21
  1663. // it will affect starting a new process.
  1664. return syscall_prlimit(pid, resource, (*syscall.Rlimit)(newlimit), (*syscall.Rlimit)(old))
  1665. }
  1666. // PrctlRetInt performs a prctl operation specified by option and further
  1667. // optional arguments arg2 through arg5 depending on option. It returns a
  1668. // non-negative integer that is returned by the prctl syscall.
  1669. func PrctlRetInt(option int, arg2 uintptr, arg3 uintptr, arg4 uintptr, arg5 uintptr) (int, error) {
  1670. ret, _, err := Syscall6(SYS_PRCTL, uintptr(option), uintptr(arg2), uintptr(arg3), uintptr(arg4), uintptr(arg5), 0)
  1671. if err != 0 {
  1672. return 0, err
  1673. }
  1674. return int(ret), nil
  1675. }
  1676. func Setuid(uid int) (err error) {
  1677. return syscall.Setuid(uid)
  1678. }
  1679. func Setgid(gid int) (err error) {
  1680. return syscall.Setgid(gid)
  1681. }
  1682. func Setreuid(ruid, euid int) (err error) {
  1683. return syscall.Setreuid(ruid, euid)
  1684. }
  1685. func Setregid(rgid, egid int) (err error) {
  1686. return syscall.Setregid(rgid, egid)
  1687. }
  1688. func Setresuid(ruid, euid, suid int) (err error) {
  1689. return syscall.Setresuid(ruid, euid, suid)
  1690. }
  1691. func Setresgid(rgid, egid, sgid int) (err error) {
  1692. return syscall.Setresgid(rgid, egid, sgid)
  1693. }
  1694. // SetfsgidRetGid sets fsgid for current thread and returns previous fsgid set.
  1695. // setfsgid(2) will return a non-nil error only if its caller lacks CAP_SETUID capability.
  1696. // If the call fails due to other reasons, current fsgid will be returned.
  1697. func SetfsgidRetGid(gid int) (int, error) {
  1698. return setfsgid(gid)
  1699. }
  1700. // SetfsuidRetUid sets fsuid for current thread and returns previous fsuid set.
  1701. // setfsgid(2) will return a non-nil error only if its caller lacks CAP_SETUID capability
  1702. // If the call fails due to other reasons, current fsuid will be returned.
  1703. func SetfsuidRetUid(uid int) (int, error) {
  1704. return setfsuid(uid)
  1705. }
  1706. func Setfsgid(gid int) error {
  1707. _, err := setfsgid(gid)
  1708. return err
  1709. }
  1710. func Setfsuid(uid int) error {
  1711. _, err := setfsuid(uid)
  1712. return err
  1713. }
  1714. func Signalfd(fd int, sigmask *Sigset_t, flags int) (newfd int, err error) {
  1715. return signalfd(fd, sigmask, _C__NSIG/8, flags)
  1716. }
  1717. //sys Setpriority(which int, who int, prio int) (err error)
  1718. //sys Setxattr(path string, attr string, data []byte, flags int) (err error)
  1719. //sys signalfd(fd int, sigmask *Sigset_t, maskSize uintptr, flags int) (newfd int, err error) = SYS_SIGNALFD4
  1720. //sys Statx(dirfd int, path string, flags int, mask int, stat *Statx_t) (err error)
  1721. //sys Sync()
  1722. //sys Syncfs(fd int) (err error)
  1723. //sysnb Sysinfo(info *Sysinfo_t) (err error)
  1724. //sys Tee(rfd int, wfd int, len int, flags int) (n int64, err error)
  1725. //sysnb TimerfdCreate(clockid int, flags int) (fd int, err error)
  1726. //sysnb TimerfdGettime(fd int, currValue *ItimerSpec) (err error)
  1727. //sysnb TimerfdSettime(fd int, flags int, newValue *ItimerSpec, oldValue *ItimerSpec) (err error)
  1728. //sysnb Tgkill(tgid int, tid int, sig syscall.Signal) (err error)
  1729. //sysnb Times(tms *Tms) (ticks uintptr, err error)
  1730. //sysnb Umask(mask int) (oldmask int)
  1731. //sysnb Uname(buf *Utsname) (err error)
  1732. //sys Unmount(target string, flags int) (err error) = SYS_UMOUNT2
  1733. //sys Unshare(flags int) (err error)
  1734. //sys write(fd int, p []byte) (n int, err error)
  1735. //sys exitThread(code int) (err error) = SYS_EXIT
  1736. //sys readv(fd int, iovs []Iovec) (n int, err error) = SYS_READV
  1737. //sys writev(fd int, iovs []Iovec) (n int, err error) = SYS_WRITEV
  1738. //sys preadv(fd int, iovs []Iovec, offs_l uintptr, offs_h uintptr) (n int, err error) = SYS_PREADV
  1739. //sys pwritev(fd int, iovs []Iovec, offs_l uintptr, offs_h uintptr) (n int, err error) = SYS_PWRITEV
  1740. //sys preadv2(fd int, iovs []Iovec, offs_l uintptr, offs_h uintptr, flags int) (n int, err error) = SYS_PREADV2
  1741. //sys pwritev2(fd int, iovs []Iovec, offs_l uintptr, offs_h uintptr, flags int) (n int, err error) = SYS_PWRITEV2
  1742. // minIovec is the size of the small initial allocation used by
  1743. // Readv, Writev, etc.
  1744. //
  1745. // This small allocation gets stack allocated, which lets the
  1746. // common use case of len(iovs) <= minIovs avoid more expensive
  1747. // heap allocations.
  1748. const minIovec = 8
  1749. // appendBytes converts bs to Iovecs and appends them to vecs.
  1750. func appendBytes(vecs []Iovec, bs [][]byte) []Iovec {
  1751. for _, b := range bs {
  1752. var v Iovec
  1753. v.SetLen(len(b))
  1754. if len(b) > 0 {
  1755. v.Base = &b[0]
  1756. } else {
  1757. v.Base = (*byte)(unsafe.Pointer(&_zero))
  1758. }
  1759. vecs = append(vecs, v)
  1760. }
  1761. return vecs
  1762. }
  1763. // offs2lohi splits offs into its low and high order bits.
  1764. func offs2lohi(offs int64) (lo, hi uintptr) {
  1765. const longBits = SizeofLong * 8
  1766. return uintptr(offs), uintptr(uint64(offs) >> (longBits - 1) >> 1) // two shifts to avoid false positive in vet
  1767. }
  1768. func Readv(fd int, iovs [][]byte) (n int, err error) {
  1769. iovecs := make([]Iovec, 0, minIovec)
  1770. iovecs = appendBytes(iovecs, iovs)
  1771. n, err = readv(fd, iovecs)
  1772. readvRacedetect(iovecs, n, err)
  1773. return n, err
  1774. }
  1775. func Preadv(fd int, iovs [][]byte, offset int64) (n int, err error) {
  1776. iovecs := make([]Iovec, 0, minIovec)
  1777. iovecs = appendBytes(iovecs, iovs)
  1778. lo, hi := offs2lohi(offset)
  1779. n, err = preadv(fd, iovecs, lo, hi)
  1780. readvRacedetect(iovecs, n, err)
  1781. return n, err
  1782. }
  1783. func Preadv2(fd int, iovs [][]byte, offset int64, flags int) (n int, err error) {
  1784. iovecs := make([]Iovec, 0, minIovec)
  1785. iovecs = appendBytes(iovecs, iovs)
  1786. lo, hi := offs2lohi(offset)
  1787. n, err = preadv2(fd, iovecs, lo, hi, flags)
  1788. readvRacedetect(iovecs, n, err)
  1789. return n, err
  1790. }
  1791. func readvRacedetect(iovecs []Iovec, n int, err error) {
  1792. if !raceenabled {
  1793. return
  1794. }
  1795. for i := 0; n > 0 && i < len(iovecs); i++ {
  1796. m := int(iovecs[i].Len)
  1797. if m > n {
  1798. m = n
  1799. }
  1800. n -= m
  1801. if m > 0 {
  1802. raceWriteRange(unsafe.Pointer(iovecs[i].Base), m)
  1803. }
  1804. }
  1805. if err == nil {
  1806. raceAcquire(unsafe.Pointer(&ioSync))
  1807. }
  1808. }
  1809. func Writev(fd int, iovs [][]byte) (n int, err error) {
  1810. iovecs := make([]Iovec, 0, minIovec)
  1811. iovecs = appendBytes(iovecs, iovs)
  1812. if raceenabled {
  1813. raceReleaseMerge(unsafe.Pointer(&ioSync))
  1814. }
  1815. n, err = writev(fd, iovecs)
  1816. writevRacedetect(iovecs, n)
  1817. return n, err
  1818. }
  1819. func Pwritev(fd int, iovs [][]byte, offset int64) (n int, err error) {
  1820. iovecs := make([]Iovec, 0, minIovec)
  1821. iovecs = appendBytes(iovecs, iovs)
  1822. if raceenabled {
  1823. raceReleaseMerge(unsafe.Pointer(&ioSync))
  1824. }
  1825. lo, hi := offs2lohi(offset)
  1826. n, err = pwritev(fd, iovecs, lo, hi)
  1827. writevRacedetect(iovecs, n)
  1828. return n, err
  1829. }
  1830. func Pwritev2(fd int, iovs [][]byte, offset int64, flags int) (n int, err error) {
  1831. iovecs := make([]Iovec, 0, minIovec)
  1832. iovecs = appendBytes(iovecs, iovs)
  1833. if raceenabled {
  1834. raceReleaseMerge(unsafe.Pointer(&ioSync))
  1835. }
  1836. lo, hi := offs2lohi(offset)
  1837. n, err = pwritev2(fd, iovecs, lo, hi, flags)
  1838. writevRacedetect(iovecs, n)
  1839. return n, err
  1840. }
  1841. func writevRacedetect(iovecs []Iovec, n int) {
  1842. if !raceenabled {
  1843. return
  1844. }
  1845. for i := 0; n > 0 && i < len(iovecs); i++ {
  1846. m := int(iovecs[i].Len)
  1847. if m > n {
  1848. m = n
  1849. }
  1850. n -= m
  1851. if m > 0 {
  1852. raceReadRange(unsafe.Pointer(iovecs[i].Base), m)
  1853. }
  1854. }
  1855. }
  1856. // mmap varies by architecture; see syscall_linux_*.go.
  1857. //sys munmap(addr uintptr, length uintptr) (err error)
  1858. //sys mremap(oldaddr uintptr, oldlength uintptr, newlength uintptr, flags int, newaddr uintptr) (xaddr uintptr, err error)
  1859. //sys Madvise(b []byte, advice int) (err error)
  1860. //sys Mprotect(b []byte, prot int) (err error)
  1861. //sys Mlock(b []byte) (err error)
  1862. //sys Mlockall(flags int) (err error)
  1863. //sys Msync(b []byte, flags int) (err error)
  1864. //sys Munlock(b []byte) (err error)
  1865. //sys Munlockall() (err error)
  1866. const (
  1867. mremapFixed = MREMAP_FIXED
  1868. mremapDontunmap = MREMAP_DONTUNMAP
  1869. mremapMaymove = MREMAP_MAYMOVE
  1870. )
  1871. // Vmsplice splices user pages from a slice of Iovecs into a pipe specified by fd,
  1872. // using the specified flags.
  1873. func Vmsplice(fd int, iovs []Iovec, flags int) (int, error) {
  1874. var p unsafe.Pointer
  1875. if len(iovs) > 0 {
  1876. p = unsafe.Pointer(&iovs[0])
  1877. }
  1878. n, _, errno := Syscall6(SYS_VMSPLICE, uintptr(fd), uintptr(p), uintptr(len(iovs)), uintptr(flags), 0, 0)
  1879. if errno != 0 {
  1880. return 0, syscall.Errno(errno)
  1881. }
  1882. return int(n), nil
  1883. }
  1884. func isGroupMember(gid int) bool {
  1885. groups, err := Getgroups()
  1886. if err != nil {
  1887. return false
  1888. }
  1889. for _, g := range groups {
  1890. if g == gid {
  1891. return true
  1892. }
  1893. }
  1894. return false
  1895. }
  1896. func isCapDacOverrideSet() bool {
  1897. hdr := CapUserHeader{Version: LINUX_CAPABILITY_VERSION_3}
  1898. data := [2]CapUserData{}
  1899. err := Capget(&hdr, &data[0])
  1900. return err == nil && data[0].Effective&(1<<CAP_DAC_OVERRIDE) != 0
  1901. }
  1902. //sys faccessat(dirfd int, path string, mode uint32) (err error)
  1903. //sys Faccessat2(dirfd int, path string, mode uint32, flags int) (err error)
  1904. func Faccessat(dirfd int, path string, mode uint32, flags int) (err error) {
  1905. if flags == 0 {
  1906. return faccessat(dirfd, path, mode)
  1907. }
  1908. if err := Faccessat2(dirfd, path, mode, flags); err != ENOSYS && err != EPERM {
  1909. return err
  1910. }
  1911. // The Linux kernel faccessat system call does not take any flags.
  1912. // The glibc faccessat implements the flags itself; see
  1913. // https://sourceware.org/git/?p=glibc.git;a=blob;f=sysdeps/unix/sysv/linux/faccessat.c;hb=HEAD
  1914. // Because people naturally expect syscall.Faccessat to act
  1915. // like C faccessat, we do the same.
  1916. if flags & ^(AT_SYMLINK_NOFOLLOW|AT_EACCESS) != 0 {
  1917. return EINVAL
  1918. }
  1919. var st Stat_t
  1920. if err := Fstatat(dirfd, path, &st, flags&AT_SYMLINK_NOFOLLOW); err != nil {
  1921. return err
  1922. }
  1923. mode &= 7
  1924. if mode == 0 {
  1925. return nil
  1926. }
  1927. var uid int
  1928. if flags&AT_EACCESS != 0 {
  1929. uid = Geteuid()
  1930. if uid != 0 && isCapDacOverrideSet() {
  1931. // If CAP_DAC_OVERRIDE is set, file access check is
  1932. // done by the kernel in the same way as for root
  1933. // (see generic_permission() in the Linux sources).
  1934. uid = 0
  1935. }
  1936. } else {
  1937. uid = Getuid()
  1938. }
  1939. if uid == 0 {
  1940. if mode&1 == 0 {
  1941. // Root can read and write any file.
  1942. return nil
  1943. }
  1944. if st.Mode&0111 != 0 {
  1945. // Root can execute any file that anybody can execute.
  1946. return nil
  1947. }
  1948. return EACCES
  1949. }
  1950. var fmode uint32
  1951. if uint32(uid) == st.Uid {
  1952. fmode = (st.Mode >> 6) & 7
  1953. } else {
  1954. var gid int
  1955. if flags&AT_EACCESS != 0 {
  1956. gid = Getegid()
  1957. } else {
  1958. gid = Getgid()
  1959. }
  1960. if uint32(gid) == st.Gid || isGroupMember(int(st.Gid)) {
  1961. fmode = (st.Mode >> 3) & 7
  1962. } else {
  1963. fmode = st.Mode & 7
  1964. }
  1965. }
  1966. if fmode&mode == mode {
  1967. return nil
  1968. }
  1969. return EACCES
  1970. }
  1971. //sys nameToHandleAt(dirFD int, pathname string, fh *fileHandle, mountID *_C_int, flags int) (err error) = SYS_NAME_TO_HANDLE_AT
  1972. //sys openByHandleAt(mountFD int, fh *fileHandle, flags int) (fd int, err error) = SYS_OPEN_BY_HANDLE_AT
  1973. // fileHandle is the argument to nameToHandleAt and openByHandleAt. We
  1974. // originally tried to generate it via unix/linux/types.go with "type
  1975. // fileHandle C.struct_file_handle" but that generated empty structs
  1976. // for mips64 and mips64le. Instead, hard code it for now (it's the
  1977. // same everywhere else) until the mips64 generator issue is fixed.
  1978. type fileHandle struct {
  1979. Bytes uint32
  1980. Type int32
  1981. }
  1982. // FileHandle represents the C struct file_handle used by
  1983. // name_to_handle_at (see NameToHandleAt) and open_by_handle_at (see
  1984. // OpenByHandleAt).
  1985. type FileHandle struct {
  1986. *fileHandle
  1987. }
  1988. // NewFileHandle constructs a FileHandle.
  1989. func NewFileHandle(handleType int32, handle []byte) FileHandle {
  1990. const hdrSize = unsafe.Sizeof(fileHandle{})
  1991. buf := make([]byte, hdrSize+uintptr(len(handle)))
  1992. copy(buf[hdrSize:], handle)
  1993. fh := (*fileHandle)(unsafe.Pointer(&buf[0]))
  1994. fh.Type = handleType
  1995. fh.Bytes = uint32(len(handle))
  1996. return FileHandle{fh}
  1997. }
  1998. func (fh *FileHandle) Size() int { return int(fh.fileHandle.Bytes) }
  1999. func (fh *FileHandle) Type() int32 { return fh.fileHandle.Type }
  2000. func (fh *FileHandle) Bytes() []byte {
  2001. n := fh.Size()
  2002. if n == 0 {
  2003. return nil
  2004. }
  2005. return unsafe.Slice((*byte)(unsafe.Pointer(uintptr(unsafe.Pointer(&fh.fileHandle.Type))+4)), n)
  2006. }
  2007. // NameToHandleAt wraps the name_to_handle_at system call; it obtains
  2008. // a handle for a path name.
  2009. func NameToHandleAt(dirfd int, path string, flags int) (handle FileHandle, mountID int, err error) {
  2010. var mid _C_int
  2011. // Try first with a small buffer, assuming the handle will
  2012. // only be 32 bytes.
  2013. size := uint32(32 + unsafe.Sizeof(fileHandle{}))
  2014. didResize := false
  2015. for {
  2016. buf := make([]byte, size)
  2017. fh := (*fileHandle)(unsafe.Pointer(&buf[0]))
  2018. fh.Bytes = size - uint32(unsafe.Sizeof(fileHandle{}))
  2019. err = nameToHandleAt(dirfd, path, fh, &mid, flags)
  2020. if err == EOVERFLOW {
  2021. if didResize {
  2022. // We shouldn't need to resize more than once
  2023. return
  2024. }
  2025. didResize = true
  2026. size = fh.Bytes + uint32(unsafe.Sizeof(fileHandle{}))
  2027. continue
  2028. }
  2029. if err != nil {
  2030. return
  2031. }
  2032. return FileHandle{fh}, int(mid), nil
  2033. }
  2034. }
  2035. // OpenByHandleAt wraps the open_by_handle_at system call; it opens a
  2036. // file via a handle as previously returned by NameToHandleAt.
  2037. func OpenByHandleAt(mountFD int, handle FileHandle, flags int) (fd int, err error) {
  2038. return openByHandleAt(mountFD, handle.fileHandle, flags)
  2039. }
  2040. // Klogset wraps the sys_syslog system call; it sets console_loglevel to
  2041. // the value specified by arg and passes a dummy pointer to bufp.
  2042. func Klogset(typ int, arg int) (err error) {
  2043. var p unsafe.Pointer
  2044. _, _, errno := Syscall(SYS_SYSLOG, uintptr(typ), uintptr(p), uintptr(arg))
  2045. if errno != 0 {
  2046. return errnoErr(errno)
  2047. }
  2048. return nil
  2049. }
  2050. // RemoteIovec is Iovec with the pointer replaced with an integer.
  2051. // It is used for ProcessVMReadv and ProcessVMWritev, where the pointer
  2052. // refers to a location in a different process' address space, which
  2053. // would confuse the Go garbage collector.
  2054. type RemoteIovec struct {
  2055. Base uintptr
  2056. Len int
  2057. }
  2058. //sys ProcessVMReadv(pid int, localIov []Iovec, remoteIov []RemoteIovec, flags uint) (n int, err error) = SYS_PROCESS_VM_READV
  2059. //sys ProcessVMWritev(pid int, localIov []Iovec, remoteIov []RemoteIovec, flags uint) (n int, err error) = SYS_PROCESS_VM_WRITEV
  2060. //sys PidfdOpen(pid int, flags int) (fd int, err error) = SYS_PIDFD_OPEN
  2061. //sys PidfdGetfd(pidfd int, targetfd int, flags int) (fd int, err error) = SYS_PIDFD_GETFD
  2062. //sys PidfdSendSignal(pidfd int, sig Signal, info *Siginfo, flags int) (err error) = SYS_PIDFD_SEND_SIGNAL
  2063. //sys shmat(id int, addr uintptr, flag int) (ret uintptr, err error)
  2064. //sys shmctl(id int, cmd int, buf *SysvShmDesc) (result int, err error)
  2065. //sys shmdt(addr uintptr) (err error)
  2066. //sys shmget(key int, size int, flag int) (id int, err error)
  2067. //sys getitimer(which int, currValue *Itimerval) (err error)
  2068. //sys setitimer(which int, newValue *Itimerval, oldValue *Itimerval) (err error)
  2069. // MakeItimerval creates an Itimerval from interval and value durations.
  2070. func MakeItimerval(interval, value time.Duration) Itimerval {
  2071. return Itimerval{
  2072. Interval: NsecToTimeval(interval.Nanoseconds()),
  2073. Value: NsecToTimeval(value.Nanoseconds()),
  2074. }
  2075. }
  2076. // A value which may be passed to the which parameter for Getitimer and
  2077. // Setitimer.
  2078. type ItimerWhich int
  2079. // Possible which values for Getitimer and Setitimer.
  2080. const (
  2081. ItimerReal ItimerWhich = ITIMER_REAL
  2082. ItimerVirtual ItimerWhich = ITIMER_VIRTUAL
  2083. ItimerProf ItimerWhich = ITIMER_PROF
  2084. )
  2085. // Getitimer wraps getitimer(2) to return the current value of the timer
  2086. // specified by which.
  2087. func Getitimer(which ItimerWhich) (Itimerval, error) {
  2088. var it Itimerval
  2089. if err := getitimer(int(which), &it); err != nil {
  2090. return Itimerval{}, err
  2091. }
  2092. return it, nil
  2093. }
  2094. // Setitimer wraps setitimer(2) to arm or disarm the timer specified by which.
  2095. // It returns the previous value of the timer.
  2096. //
  2097. // If the Itimerval argument is the zero value, the timer will be disarmed.
  2098. func Setitimer(which ItimerWhich, it Itimerval) (Itimerval, error) {
  2099. var prev Itimerval
  2100. if err := setitimer(int(which), &it, &prev); err != nil {
  2101. return Itimerval{}, err
  2102. }
  2103. return prev, nil
  2104. }
  2105. //sysnb rtSigprocmask(how int, set *Sigset_t, oldset *Sigset_t, sigsetsize uintptr) (err error) = SYS_RT_SIGPROCMASK
  2106. func PthreadSigmask(how int, set, oldset *Sigset_t) error {
  2107. if oldset != nil {
  2108. // Explicitly clear in case Sigset_t is larger than _C__NSIG.
  2109. *oldset = Sigset_t{}
  2110. }
  2111. return rtSigprocmask(how, set, oldset, _C__NSIG/8)
  2112. }
  2113. //sysnb getresuid(ruid *_C_int, euid *_C_int, suid *_C_int)
  2114. //sysnb getresgid(rgid *_C_int, egid *_C_int, sgid *_C_int)
  2115. func Getresuid() (ruid, euid, suid int) {
  2116. var r, e, s _C_int
  2117. getresuid(&r, &e, &s)
  2118. return int(r), int(e), int(s)
  2119. }
  2120. func Getresgid() (rgid, egid, sgid int) {
  2121. var r, e, s _C_int
  2122. getresgid(&r, &e, &s)
  2123. return int(r), int(e), int(s)
  2124. }
  2125. // Pselect is a wrapper around the Linux pselect6 system call.
  2126. // This version does not modify the timeout argument.
  2127. func Pselect(nfd int, r *FdSet, w *FdSet, e *FdSet, timeout *Timespec, sigmask *Sigset_t) (n int, err error) {
  2128. // Per https://man7.org/linux/man-pages/man2/select.2.html#NOTES,
  2129. // The Linux pselect6() system call modifies its timeout argument.
  2130. // [Not modifying the argument] is the behavior required by POSIX.1-2001.
  2131. var mutableTimeout *Timespec
  2132. if timeout != nil {
  2133. mutableTimeout = new(Timespec)
  2134. *mutableTimeout = *timeout
  2135. }
  2136. // The final argument of the pselect6() system call is not a
  2137. // sigset_t * pointer, but is instead a structure
  2138. var kernelMask *sigset_argpack
  2139. if sigmask != nil {
  2140. wordBits := 32 << (^uintptr(0) >> 63) // see math.intSize
  2141. // A sigset stores one bit per signal,
  2142. // offset by 1 (because signal 0 does not exist).
  2143. // So the number of words needed is ⌈__C_NSIG - 1 / wordBits⌉.
  2144. sigsetWords := (_C__NSIG - 1 + wordBits - 1) / (wordBits)
  2145. sigsetBytes := uintptr(sigsetWords * (wordBits / 8))
  2146. kernelMask = &sigset_argpack{
  2147. ss: sigmask,
  2148. ssLen: sigsetBytes,
  2149. }
  2150. }
  2151. return pselect6(nfd, r, w, e, mutableTimeout, kernelMask)
  2152. }
  2153. //sys schedSetattr(pid int, attr *SchedAttr, flags uint) (err error)
  2154. //sys schedGetattr(pid int, attr *SchedAttr, size uint, flags uint) (err error)
  2155. // SchedSetAttr is a wrapper for sched_setattr(2) syscall.
  2156. // https://man7.org/linux/man-pages/man2/sched_setattr.2.html
  2157. func SchedSetAttr(pid int, attr *SchedAttr, flags uint) error {
  2158. if attr == nil {
  2159. return EINVAL
  2160. }
  2161. attr.Size = SizeofSchedAttr
  2162. return schedSetattr(pid, attr, flags)
  2163. }
  2164. // SchedGetAttr is a wrapper for sched_getattr(2) syscall.
  2165. // https://man7.org/linux/man-pages/man2/sched_getattr.2.html
  2166. func SchedGetAttr(pid int, flags uint) (*SchedAttr, error) {
  2167. attr := &SchedAttr{}
  2168. if err := schedGetattr(pid, attr, SizeofSchedAttr, flags); err != nil {
  2169. return nil, err
  2170. }
  2171. return attr, nil
  2172. }