socket.c 84 KB

12345678910111213141516171819202122232425262728293031323334353637383940414243444546474849505152535455565758596061626364656667686970717273747576777879808182838485868788899091929394959697989910010110210310410510610710810911011111211311411511611711811912012112212312412512612712812913013113213313413513613713813914014114214314414514614714814915015115215315415515615715815916016116216316416516616716816917017117217317417517617717817918018118218318418518618718818919019119219319419519619719819920020120220320420520620720820921021121221321421521621721821922022122222322422522622722822923023123223323423523623723823924024124224324424524624724824925025125225325425525625725825926026126226326426526626726826927027127227327427527627727827928028128228328428528628728828929029129229329429529629729829930030130230330430530630730830931031131231331431531631731831932032132232332432532632732832933033133233333433533633733833934034134234334434534634734834935035135235335435535635735835936036136236336436536636736836937037137237337437537637737837938038138238338438538638738838939039139239339439539639739839940040140240340440540640740840941041141241341441541641741841942042142242342442542642742842943043143243343443543643743843944044144244344444544644744844945045145245345445545645745845946046146246346446546646746846947047147247347447547647747847948048148248348448548648748848949049149249349449549649749849950050150250350450550650750850951051151251351451551651751851952052152252352452552652752852953053153253353453553653753853954054154254354454554654754854955055155255355455555655755855956056156256356456556656756856957057157257357457557657757857958058158258358458558658758858959059159259359459559659759859960060160260360460560660760860961061161261361461561661761861962062162262362462562662762862963063163263363463563663763863964064164264364464564664764864965065165265365465565665765865966066166266366466566666766866967067167267367467567667767867968068168268368468568668768868969069169269369469569669769869970070170270370470570670770870971071171271371471571671771871972072172272372472572672772872973073173273373473573673773873974074174274374474574674774874975075175275375475575675775875976076176276376476576676776876977077177277377477577677777877978078178278378478578678778878979079179279379479579679779879980080180280380480580680780880981081181281381481581681781881982082182282382482582682782882983083183283383483583683783883984084184284384484584684784884985085185285385485585685785885986086186286386486586686786886987087187287387487587687787887988088188288388488588688788888989089189289389489589689789889990090190290390490590690790890991091191291391491591691791891992092192292392492592692792892993093193293393493593693793893994094194294394494594694794894995095195295395495595695795895996096196296396496596696796896997097197297397497597697797897998098198298398498598698798898999099199299399499599699799899910001001100210031004100510061007100810091010101110121013101410151016101710181019102010211022102310241025102610271028102910301031103210331034103510361037103810391040104110421043104410451046104710481049105010511052105310541055105610571058105910601061106210631064106510661067106810691070107110721073107410751076107710781079108010811082108310841085108610871088108910901091109210931094109510961097109810991100110111021103110411051106110711081109111011111112111311141115111611171118111911201121112211231124112511261127112811291130113111321133113411351136113711381139114011411142114311441145114611471148114911501151115211531154115511561157115811591160116111621163116411651166116711681169117011711172117311741175117611771178117911801181118211831184118511861187118811891190119111921193119411951196119711981199120012011202120312041205120612071208120912101211121212131214121512161217121812191220122112221223122412251226122712281229123012311232123312341235123612371238123912401241124212431244124512461247124812491250125112521253125412551256125712581259126012611262126312641265126612671268126912701271127212731274127512761277127812791280128112821283128412851286128712881289129012911292129312941295129612971298129913001301130213031304130513061307130813091310131113121313131413151316131713181319132013211322132313241325132613271328132913301331133213331334133513361337133813391340134113421343134413451346134713481349135013511352135313541355135613571358135913601361136213631364136513661367136813691370137113721373137413751376137713781379138013811382138313841385138613871388138913901391139213931394139513961397139813991400140114021403140414051406140714081409141014111412141314141415141614171418141914201421142214231424142514261427142814291430143114321433143414351436143714381439144014411442144314441445144614471448144914501451145214531454145514561457145814591460146114621463146414651466146714681469147014711472147314741475147614771478147914801481148214831484148514861487148814891490149114921493149414951496149714981499150015011502150315041505150615071508150915101511151215131514151515161517151815191520152115221523152415251526152715281529153015311532153315341535153615371538153915401541154215431544154515461547154815491550155115521553155415551556155715581559156015611562156315641565156615671568156915701571157215731574157515761577157815791580158115821583158415851586158715881589159015911592159315941595159615971598159916001601160216031604160516061607160816091610161116121613161416151616161716181619162016211622162316241625162616271628162916301631163216331634163516361637163816391640164116421643164416451646164716481649165016511652165316541655165616571658165916601661166216631664166516661667166816691670167116721673167416751676167716781679168016811682168316841685168616871688168916901691169216931694169516961697169816991700170117021703170417051706170717081709171017111712171317141715171617171718171917201721172217231724172517261727172817291730173117321733173417351736173717381739174017411742174317441745174617471748174917501751175217531754175517561757175817591760176117621763176417651766176717681769177017711772177317741775177617771778177917801781178217831784178517861787178817891790179117921793179417951796179717981799180018011802180318041805180618071808180918101811181218131814181518161817181818191820182118221823182418251826182718281829183018311832183318341835183618371838183918401841184218431844184518461847184818491850185118521853185418551856185718581859186018611862186318641865186618671868186918701871187218731874187518761877187818791880188118821883188418851886188718881889189018911892189318941895189618971898189919001901190219031904190519061907190819091910191119121913191419151916191719181919192019211922192319241925192619271928192919301931193219331934193519361937193819391940194119421943194419451946194719481949195019511952195319541955195619571958195919601961196219631964196519661967196819691970197119721973197419751976197719781979198019811982198319841985198619871988198919901991199219931994199519961997199819992000200120022003200420052006200720082009201020112012201320142015201620172018201920202021202220232024202520262027202820292030203120322033203420352036203720382039204020412042204320442045204620472048204920502051205220532054205520562057205820592060206120622063206420652066206720682069207020712072207320742075207620772078207920802081208220832084208520862087208820892090209120922093209420952096209720982099210021012102210321042105210621072108210921102111211221132114211521162117211821192120212121222123212421252126212721282129213021312132213321342135213621372138213921402141214221432144214521462147214821492150215121522153215421552156215721582159216021612162216321642165216621672168216921702171217221732174217521762177217821792180218121822183218421852186218721882189219021912192219321942195219621972198219922002201220222032204220522062207220822092210221122122213221422152216221722182219222022212222222322242225222622272228222922302231223222332234223522362237223822392240224122422243224422452246224722482249225022512252225322542255225622572258225922602261226222632264226522662267226822692270227122722273227422752276227722782279228022812282228322842285228622872288228922902291229222932294229522962297229822992300230123022303230423052306230723082309231023112312231323142315231623172318231923202321232223232324232523262327232823292330233123322333233423352336233723382339234023412342234323442345234623472348234923502351235223532354235523562357235823592360236123622363236423652366236723682369237023712372237323742375237623772378237923802381238223832384238523862387238823892390239123922393239423952396239723982399240024012402240324042405240624072408240924102411241224132414241524162417241824192420242124222423242424252426242724282429243024312432243324342435243624372438243924402441244224432444244524462447244824492450245124522453245424552456245724582459246024612462246324642465246624672468246924702471247224732474247524762477247824792480248124822483248424852486248724882489249024912492249324942495249624972498249925002501250225032504250525062507250825092510251125122513251425152516251725182519252025212522252325242525252625272528252925302531253225332534253525362537253825392540254125422543254425452546254725482549255025512552255325542555255625572558255925602561256225632564256525662567256825692570257125722573257425752576257725782579258025812582258325842585258625872588258925902591259225932594259525962597259825992600260126022603260426052606260726082609261026112612261326142615261626172618261926202621262226232624262526262627262826292630263126322633263426352636263726382639264026412642264326442645264626472648264926502651265226532654265526562657265826592660266126622663266426652666266726682669267026712672267326742675267626772678267926802681268226832684268526862687268826892690269126922693269426952696269726982699270027012702270327042705270627072708270927102711271227132714271527162717271827192720272127222723272427252726272727282729273027312732273327342735273627372738273927402741274227432744274527462747274827492750275127522753275427552756275727582759276027612762276327642765276627672768276927702771277227732774277527762777277827792780278127822783278427852786278727882789279027912792279327942795279627972798279928002801280228032804280528062807280828092810281128122813281428152816281728182819282028212822282328242825282628272828282928302831283228332834283528362837283828392840284128422843284428452846284728482849285028512852285328542855285628572858285928602861286228632864286528662867286828692870287128722873287428752876287728782879288028812882288328842885288628872888288928902891289228932894289528962897289828992900290129022903290429052906290729082909291029112912291329142915291629172918291929202921292229232924292529262927292829292930293129322933293429352936293729382939294029412942294329442945294629472948294929502951295229532954295529562957295829592960296129622963296429652966296729682969297029712972297329742975297629772978297929802981298229832984298529862987298829892990299129922993299429952996299729982999300030013002300330043005300630073008300930103011301230133014301530163017301830193020302130223023302430253026302730283029303030313032303330343035303630373038303930403041304230433044304530463047304830493050305130523053305430553056305730583059306030613062306330643065306630673068306930703071307230733074307530763077307830793080308130823083308430853086308730883089309030913092309330943095309630973098309931003101310231033104310531063107310831093110311131123113311431153116311731183119312031213122312331243125312631273128312931303131313231333134313531363137313831393140314131423143314431453146314731483149315031513152315331543155315631573158315931603161316231633164316531663167316831693170317131723173317431753176317731783179318031813182318331843185318631873188318931903191319231933194319531963197319831993200320132023203320432053206320732083209321032113212321332143215321632173218321932203221322232233224322532263227322832293230323132323233323432353236323732383239324032413242324332443245324632473248324932503251325232533254325532563257325832593260326132623263326432653266326732683269327032713272327332743275327632773278327932803281328232833284328532863287328832893290329132923293329432953296329732983299330033013302330333043305330633073308330933103311331233133314331533163317331833193320332133223323332433253326332733283329333033313332333333343335333633373338333933403341334233433344334533463347334833493350335133523353335433553356335733583359336033613362336333643365336633673368336933703371337233733374337533763377337833793380338133823383338433853386338733883389339033913392339333943395339633973398339934003401340234033404340534063407340834093410341134123413341434153416341734183419342034213422342334243425342634273428342934303431343234333434343534363437343834393440344134423443344434453446344734483449345034513452345334543455345634573458345934603461346234633464346534663467346834693470347134723473347434753476347734783479348034813482348334843485
  1. /*
  2. * NET An implementation of the SOCKET network access protocol.
  3. *
  4. * Version: @(#)socket.c 1.1.93 18/02/95
  5. *
  6. * Authors: Orest Zborowski, <obz@Kodak.COM>
  7. * Ross Biro
  8. * Fred N. van Kempen, <waltje@uWalt.NL.Mugnet.ORG>
  9. *
  10. * Fixes:
  11. * Anonymous : NOTSOCK/BADF cleanup. Error fix in
  12. * shutdown()
  13. * Alan Cox : verify_area() fixes
  14. * Alan Cox : Removed DDI
  15. * Jonathan Kamens : SOCK_DGRAM reconnect bug
  16. * Alan Cox : Moved a load of checks to the very
  17. * top level.
  18. * Alan Cox : Move address structures to/from user
  19. * mode above the protocol layers.
  20. * Rob Janssen : Allow 0 length sends.
  21. * Alan Cox : Asynchronous I/O support (cribbed from the
  22. * tty drivers).
  23. * Niibe Yutaka : Asynchronous I/O for writes (4.4BSD style)
  24. * Jeff Uphoff : Made max number of sockets command-line
  25. * configurable.
  26. * Matti Aarnio : Made the number of sockets dynamic,
  27. * to be allocated when needed, and mr.
  28. * Uphoff's max is used as max to be
  29. * allowed to allocate.
  30. * Linus : Argh. removed all the socket allocation
  31. * altogether: it's in the inode now.
  32. * Alan Cox : Made sock_alloc()/sock_release() public
  33. * for NetROM and future kernel nfsd type
  34. * stuff.
  35. * Alan Cox : sendmsg/recvmsg basics.
  36. * Tom Dyas : Export net symbols.
  37. * Marcin Dalecki : Fixed problems with CONFIG_NET="n".
  38. * Alan Cox : Added thread locking to sys_* calls
  39. * for sockets. May have errors at the
  40. * moment.
  41. * Kevin Buhr : Fixed the dumb errors in the above.
  42. * Andi Kleen : Some small cleanups, optimizations,
  43. * and fixed a copy_from_user() bug.
  44. * Tigran Aivazian : sys_send(args) calls sys_sendto(args, NULL, 0)
  45. * Tigran Aivazian : Made listen(2) backlog sanity checks
  46. * protocol-independent
  47. *
  48. *
  49. * This program is free software; you can redistribute it and/or
  50. * modify it under the terms of the GNU General Public License
  51. * as published by the Free Software Foundation; either version
  52. * 2 of the License, or (at your option) any later version.
  53. *
  54. *
  55. * This module is effectively the top level interface to the BSD socket
  56. * paradigm.
  57. *
  58. * Based upon Swansea University Computer Society NET3.039
  59. */
  60. #include <linux/mm.h>
  61. #include <linux/socket.h>
  62. #include <linux/file.h>
  63. #include <linux/net.h>
  64. #include <linux/interrupt.h>
  65. #include <linux/thread_info.h>
  66. #include <linux/rcupdate.h>
  67. #include <linux/netdevice.h>
  68. #include <linux/proc_fs.h>
  69. #include <linux/seq_file.h>
  70. #include <linux/mutex.h>
  71. #include <linux/if_bridge.h>
  72. #include <linux/if_frad.h>
  73. #include <linux/if_vlan.h>
  74. #include <linux/init.h>
  75. #include <linux/poll.h>
  76. #include <linux/cache.h>
  77. #include <linux/module.h>
  78. #include <linux/highmem.h>
  79. #include <linux/mount.h>
  80. #include <linux/security.h>
  81. #include <linux/syscalls.h>
  82. #include <linux/compat.h>
  83. #include <linux/kmod.h>
  84. #include <linux/audit.h>
  85. #include <linux/wireless.h>
  86. #include <linux/nsproxy.h>
  87. #include <linux/magic.h>
  88. #include <linux/slab.h>
  89. #include <linux/xattr.h>
  90. #include <asm/uaccess.h>
  91. #include <asm/unistd.h>
  92. #include <net/compat.h>
  93. #include <net/wext.h>
  94. #include <net/cls_cgroup.h>
  95. #include <net/sock.h>
  96. #include <linux/netfilter.h>
  97. #include <linux/if_tun.h>
  98. #include <linux/ipv6_route.h>
  99. #include <linux/route.h>
  100. #include <linux/sockios.h>
  101. #include <linux/atalk.h>
  102. #include <net/busy_poll.h>
  103. #ifdef CONFIG_NET_RX_BUSY_POLL
  104. unsigned int sysctl_net_busy_read __read_mostly;
  105. unsigned int sysctl_net_busy_poll __read_mostly;
  106. #endif
  107. static int sock_no_open(struct inode *irrelevant, struct file *dontcare);
  108. static ssize_t sock_aio_read(struct kiocb *iocb, const struct iovec *iov,
  109. unsigned long nr_segs, loff_t pos);
  110. static ssize_t sock_aio_write(struct kiocb *iocb, const struct iovec *iov,
  111. unsigned long nr_segs, loff_t pos);
  112. static int sock_mmap(struct file *file, struct vm_area_struct *vma);
  113. static int sock_close(struct inode *inode, struct file *file);
  114. static unsigned int sock_poll(struct file *file,
  115. struct poll_table_struct *wait);
  116. static long sock_ioctl(struct file *file, unsigned int cmd, unsigned long arg);
  117. #ifdef CONFIG_COMPAT
  118. static long compat_sock_ioctl(struct file *file,
  119. unsigned int cmd, unsigned long arg);
  120. #endif
  121. static int sock_fasync(int fd, struct file *filp, int on);
  122. static ssize_t sock_sendpage(struct file *file, struct page *page,
  123. int offset, size_t size, loff_t *ppos, int more);
  124. static ssize_t sock_splice_read(struct file *file, loff_t *ppos,
  125. struct pipe_inode_info *pipe, size_t len,
  126. unsigned int flags);
  127. /*
  128. * Socket files have a set of 'special' operations as well as the generic file ones. These don't appear
  129. * in the operation structures but are done directly via the socketcall() multiplexor.
  130. */
  131. static const struct file_operations socket_file_ops = {
  132. .owner = THIS_MODULE,
  133. .llseek = no_llseek,
  134. .aio_read = sock_aio_read,
  135. .aio_write = sock_aio_write,
  136. .poll = sock_poll,
  137. .unlocked_ioctl = sock_ioctl,
  138. #ifdef CONFIG_COMPAT
  139. .compat_ioctl = compat_sock_ioctl,
  140. #endif
  141. .mmap = sock_mmap,
  142. .open = sock_no_open, /* special open code to disallow open via /proc */
  143. .release = sock_close,
  144. .fasync = sock_fasync,
  145. .sendpage = sock_sendpage,
  146. .splice_write = generic_splice_sendpage,
  147. .splice_read = sock_splice_read,
  148. };
  149. /*
  150. * The protocol list. Each protocol is registered in here.
  151. */
  152. static DEFINE_SPINLOCK(net_family_lock);
  153. static const struct net_proto_family __rcu *net_families[NPROTO] __read_mostly;
  154. /*
  155. * Statistics counters of the socket lists
  156. */
  157. static DEFINE_PER_CPU(int, sockets_in_use);
  158. /*
  159. * Support routines.
  160. * Move socket addresses back and forth across the kernel/user
  161. * divide and look after the messy bits.
  162. */
  163. /**
  164. * move_addr_to_kernel - copy a socket address into kernel space
  165. * @uaddr: Address in user space
  166. * @kaddr: Address in kernel space
  167. * @ulen: Length in user space
  168. *
  169. * The address is copied into kernel space. If the provided address is
  170. * too long an error code of -EINVAL is returned. If the copy gives
  171. * invalid addresses -EFAULT is returned. On a success 0 is returned.
  172. */
  173. int move_addr_to_kernel(void __user *uaddr, int ulen, struct sockaddr_storage *kaddr)
  174. {
  175. if (ulen < 0 || ulen > sizeof(struct sockaddr_storage))
  176. return -EINVAL;
  177. if (ulen == 0)
  178. return 0;
  179. if (copy_from_user(kaddr, uaddr, ulen))
  180. return -EFAULT;
  181. return audit_sockaddr(ulen, kaddr);
  182. }
  183. /**
  184. * move_addr_to_user - copy an address to user space
  185. * @kaddr: kernel space address
  186. * @klen: length of address in kernel
  187. * @uaddr: user space address
  188. * @ulen: pointer to user length field
  189. *
  190. * The value pointed to by ulen on entry is the buffer length available.
  191. * This is overwritten with the buffer space used. -EINVAL is returned
  192. * if an overlong buffer is specified or a negative buffer size. -EFAULT
  193. * is returned if either the buffer or the length field are not
  194. * accessible.
  195. * After copying the data up to the limit the user specifies, the true
  196. * length of the data is written over the length limit the user
  197. * specified. Zero is returned for a success.
  198. */
  199. static int move_addr_to_user(struct sockaddr_storage *kaddr, int klen,
  200. void __user *uaddr, int __user *ulen)
  201. {
  202. int err;
  203. int len;
  204. err = get_user(len, ulen);
  205. if (err)
  206. return err;
  207. if (len > klen)
  208. len = klen;
  209. if (len < 0 || len > sizeof(struct sockaddr_storage))
  210. return -EINVAL;
  211. if (len) {
  212. if (audit_sockaddr(klen, kaddr))
  213. return -ENOMEM;
  214. if (copy_to_user(uaddr, kaddr, len))
  215. return -EFAULT;
  216. }
  217. /*
  218. * "fromlen shall refer to the value before truncation.."
  219. * 1003.1g
  220. */
  221. return __put_user(klen, ulen);
  222. }
  223. static struct kmem_cache *sock_inode_cachep __read_mostly;
  224. static struct inode *sock_alloc_inode(struct super_block *sb)
  225. {
  226. struct socket_alloc *ei;
  227. struct socket_wq *wq;
  228. ei = kmem_cache_alloc(sock_inode_cachep, GFP_KERNEL);
  229. if (!ei)
  230. return NULL;
  231. wq = kmalloc(sizeof(*wq), GFP_KERNEL);
  232. if (!wq) {
  233. kmem_cache_free(sock_inode_cachep, ei);
  234. return NULL;
  235. }
  236. init_waitqueue_head(&wq->wait);
  237. wq->fasync_list = NULL;
  238. RCU_INIT_POINTER(ei->socket.wq, wq);
  239. ei->socket.state = SS_UNCONNECTED;
  240. ei->socket.flags = 0;
  241. ei->socket.ops = NULL;
  242. ei->socket.sk = NULL;
  243. ei->socket.file = NULL;
  244. return &ei->vfs_inode;
  245. }
  246. static void sock_destroy_inode(struct inode *inode)
  247. {
  248. struct socket_alloc *ei;
  249. struct socket_wq *wq;
  250. ei = container_of(inode, struct socket_alloc, vfs_inode);
  251. wq = rcu_dereference_protected(ei->socket.wq, 1);
  252. kfree_rcu(wq, rcu);
  253. kmem_cache_free(sock_inode_cachep, ei);
  254. }
  255. static void init_once(void *foo)
  256. {
  257. struct socket_alloc *ei = (struct socket_alloc *)foo;
  258. inode_init_once(&ei->vfs_inode);
  259. }
  260. static int init_inodecache(void)
  261. {
  262. sock_inode_cachep = kmem_cache_create("sock_inode_cache",
  263. sizeof(struct socket_alloc),
  264. 0,
  265. (SLAB_HWCACHE_ALIGN |
  266. SLAB_RECLAIM_ACCOUNT |
  267. SLAB_MEM_SPREAD),
  268. init_once);
  269. if (sock_inode_cachep == NULL)
  270. return -ENOMEM;
  271. return 0;
  272. }
  273. static const struct super_operations sockfs_ops = {
  274. .alloc_inode = sock_alloc_inode,
  275. .destroy_inode = sock_destroy_inode,
  276. .statfs = simple_statfs,
  277. };
  278. /*
  279. * sockfs_dname() is called from d_path().
  280. */
  281. static char *sockfs_dname(struct dentry *dentry, char *buffer, int buflen)
  282. {
  283. return dynamic_dname(dentry, buffer, buflen, "socket:[%lu]",
  284. dentry->d_inode->i_ino);
  285. }
  286. static const struct dentry_operations sockfs_dentry_operations = {
  287. .d_dname = sockfs_dname,
  288. };
  289. static struct dentry *sockfs_mount(struct file_system_type *fs_type,
  290. int flags, const char *dev_name, void *data)
  291. {
  292. return mount_pseudo(fs_type, "socket:", &sockfs_ops,
  293. &sockfs_dentry_operations, SOCKFS_MAGIC);
  294. }
  295. static struct vfsmount *sock_mnt __read_mostly;
  296. static struct file_system_type sock_fs_type = {
  297. .name = "sockfs",
  298. .mount = sockfs_mount,
  299. .kill_sb = kill_anon_super,
  300. };
  301. /*
  302. * Obtains the first available file descriptor and sets it up for use.
  303. *
  304. * These functions create file structures and maps them to fd space
  305. * of the current process. On success it returns file descriptor
  306. * and file struct implicitly stored in sock->file.
  307. * Note that another thread may close file descriptor before we return
  308. * from this function. We use the fact that now we do not refer
  309. * to socket after mapping. If one day we will need it, this
  310. * function will increment ref. count on file by 1.
  311. *
  312. * In any case returned fd MAY BE not valid!
  313. * This race condition is unavoidable
  314. * with shared fd spaces, we cannot solve it inside kernel,
  315. * but we take care of internal coherence yet.
  316. */
  317. struct file *sock_alloc_file(struct socket *sock, int flags, const char *dname)
  318. {
  319. struct qstr name = { .name = "" };
  320. struct path path;
  321. struct file *file;
  322. if (dname) {
  323. name.name = dname;
  324. name.len = strlen(name.name);
  325. } else if (sock->sk) {
  326. name.name = sock->sk->sk_prot_creator->name;
  327. name.len = strlen(name.name);
  328. }
  329. path.dentry = d_alloc_pseudo(sock_mnt->mnt_sb, &name);
  330. if (unlikely(!path.dentry))
  331. return ERR_PTR(-ENOMEM);
  332. path.mnt = mntget(sock_mnt);
  333. d_instantiate(path.dentry, SOCK_INODE(sock));
  334. SOCK_INODE(sock)->i_fop = &socket_file_ops;
  335. file = alloc_file(&path, FMODE_READ | FMODE_WRITE,
  336. &socket_file_ops);
  337. if (unlikely(IS_ERR(file))) {
  338. /* drop dentry, keep inode */
  339. ihold(path.dentry->d_inode);
  340. path_put(&path);
  341. return file;
  342. }
  343. sock->file = file;
  344. file->f_flags = O_RDWR | (flags & O_NONBLOCK);
  345. file->private_data = sock;
  346. return file;
  347. }
  348. EXPORT_SYMBOL(sock_alloc_file);
  349. static int sock_map_fd(struct socket *sock, int flags)
  350. {
  351. struct file *newfile;
  352. int fd = get_unused_fd_flags(flags);
  353. if (unlikely(fd < 0))
  354. return fd;
  355. newfile = sock_alloc_file(sock, flags, NULL);
  356. if (likely(!IS_ERR(newfile))) {
  357. fd_install(fd, newfile);
  358. return fd;
  359. }
  360. put_unused_fd(fd);
  361. return PTR_ERR(newfile);
  362. }
  363. struct socket *sock_from_file(struct file *file, int *err)
  364. {
  365. if (file->f_op == &socket_file_ops)
  366. return file->private_data; /* set in sock_map_fd */
  367. *err = -ENOTSOCK;
  368. return NULL;
  369. }
  370. EXPORT_SYMBOL(sock_from_file);
  371. /**
  372. * sockfd_lookup - Go from a file number to its socket slot
  373. * @fd: file handle
  374. * @err: pointer to an error code return
  375. *
  376. * The file handle passed in is locked and the socket it is bound
  377. * too is returned. If an error occurs the err pointer is overwritten
  378. * with a negative errno code and NULL is returned. The function checks
  379. * for both invalid handles and passing a handle which is not a socket.
  380. *
  381. * On a success the socket object pointer is returned.
  382. */
  383. struct socket *sockfd_lookup(int fd, int *err)
  384. {
  385. struct file *file;
  386. struct socket *sock;
  387. file = fget(fd);
  388. if (!file) {
  389. *err = -EBADF;
  390. return NULL;
  391. }
  392. sock = sock_from_file(file, err);
  393. if (!sock)
  394. fput(file);
  395. return sock;
  396. }
  397. EXPORT_SYMBOL(sockfd_lookup);
  398. static struct socket *sockfd_lookup_light(int fd, int *err, int *fput_needed)
  399. {
  400. struct file *file;
  401. struct socket *sock;
  402. *err = -EBADF;
  403. file = fget_light(fd, fput_needed);
  404. if (file) {
  405. sock = sock_from_file(file, err);
  406. if (sock)
  407. return sock;
  408. fput_light(file, *fput_needed);
  409. }
  410. return NULL;
  411. }
  412. #define XATTR_SOCKPROTONAME_SUFFIX "sockprotoname"
  413. #define XATTR_NAME_SOCKPROTONAME (XATTR_SYSTEM_PREFIX XATTR_SOCKPROTONAME_SUFFIX)
  414. #define XATTR_NAME_SOCKPROTONAME_LEN (sizeof(XATTR_NAME_SOCKPROTONAME)-1)
  415. static ssize_t sockfs_getxattr(struct dentry *dentry,
  416. const char *name, void *value, size_t size)
  417. {
  418. const char *proto_name;
  419. size_t proto_size;
  420. int error;
  421. error = -ENODATA;
  422. if (!strncmp(name, XATTR_NAME_SOCKPROTONAME, XATTR_NAME_SOCKPROTONAME_LEN)) {
  423. proto_name = dentry->d_name.name;
  424. proto_size = strlen(proto_name);
  425. if (value) {
  426. error = -ERANGE;
  427. if (proto_size + 1 > size)
  428. goto out;
  429. strncpy(value, proto_name, proto_size + 1);
  430. }
  431. error = proto_size + 1;
  432. }
  433. out:
  434. return error;
  435. }
  436. static ssize_t sockfs_listxattr(struct dentry *dentry, char *buffer,
  437. size_t size)
  438. {
  439. ssize_t len;
  440. ssize_t used = 0;
  441. len = security_inode_listsecurity(dentry->d_inode, buffer, size);
  442. if (len < 0)
  443. return len;
  444. used += len;
  445. if (buffer) {
  446. if (size < used)
  447. return -ERANGE;
  448. buffer += len;
  449. }
  450. len = (XATTR_NAME_SOCKPROTONAME_LEN + 1);
  451. used += len;
  452. if (buffer) {
  453. if (size < used)
  454. return -ERANGE;
  455. memcpy(buffer, XATTR_NAME_SOCKPROTONAME, len);
  456. buffer += len;
  457. }
  458. return used;
  459. }
  460. static const struct inode_operations sockfs_inode_ops = {
  461. .getxattr = sockfs_getxattr,
  462. .listxattr = sockfs_listxattr,
  463. };
  464. /**
  465. * sock_alloc - allocate a socket
  466. *
  467. * Allocate a new inode and socket object. The two are bound together
  468. * and initialised. The socket is then returned. If we are out of inodes
  469. * NULL is returned.
  470. */
  471. static struct socket *sock_alloc(void)
  472. {
  473. struct inode *inode;
  474. struct socket *sock;
  475. inode = new_inode_pseudo(sock_mnt->mnt_sb);
  476. if (!inode)
  477. return NULL;
  478. sock = SOCKET_I(inode);
  479. kmemcheck_annotate_bitfield(sock, type);
  480. inode->i_ino = get_next_ino();
  481. inode->i_mode = S_IFSOCK | S_IRWXUGO;
  482. inode->i_uid = current_fsuid();
  483. inode->i_gid = current_fsgid();
  484. inode->i_op = &sockfs_inode_ops;
  485. this_cpu_add(sockets_in_use, 1);
  486. return sock;
  487. }
  488. /*
  489. * In theory you can't get an open on this inode, but /proc provides
  490. * a back door. Remember to keep it shut otherwise you'll let the
  491. * creepy crawlies in.
  492. */
  493. static int sock_no_open(struct inode *irrelevant, struct file *dontcare)
  494. {
  495. return -ENXIO;
  496. }
  497. const struct file_operations bad_sock_fops = {
  498. .owner = THIS_MODULE,
  499. .open = sock_no_open,
  500. .llseek = noop_llseek,
  501. };
  502. /**
  503. * sock_release - close a socket
  504. * @sock: socket to close
  505. *
  506. * The socket is released from the protocol stack if it has a release
  507. * callback, and the inode is then released if the socket is bound to
  508. * an inode not a file.
  509. */
  510. void sock_release(struct socket *sock)
  511. {
  512. if (sock->ops) {
  513. struct module *owner = sock->ops->owner;
  514. sock->ops->release(sock);
  515. sock->ops = NULL;
  516. module_put(owner);
  517. }
  518. if (rcu_dereference_protected(sock->wq, 1)->fasync_list)
  519. printk(KERN_ERR "sock_release: fasync list not empty!\n");
  520. if (test_bit(SOCK_EXTERNALLY_ALLOCATED, &sock->flags))
  521. return;
  522. this_cpu_sub(sockets_in_use, 1);
  523. if (!sock->file) {
  524. iput(SOCK_INODE(sock));
  525. return;
  526. }
  527. sock->file = NULL;
  528. }
  529. EXPORT_SYMBOL(sock_release);
  530. void sock_tx_timestamp(struct sock *sk, __u8 *tx_flags)
  531. {
  532. *tx_flags = 0;
  533. if (sock_flag(sk, SOCK_TIMESTAMPING_TX_HARDWARE))
  534. *tx_flags |= SKBTX_HW_TSTAMP;
  535. if (sock_flag(sk, SOCK_TIMESTAMPING_TX_SOFTWARE))
  536. *tx_flags |= SKBTX_SW_TSTAMP;
  537. if (sock_flag(sk, SOCK_WIFI_STATUS))
  538. *tx_flags |= SKBTX_WIFI_STATUS;
  539. }
  540. EXPORT_SYMBOL(sock_tx_timestamp);
  541. static inline int __sock_sendmsg_nosec(struct kiocb *iocb, struct socket *sock,
  542. struct msghdr *msg, size_t size)
  543. {
  544. struct sock_iocb *si = kiocb_to_siocb(iocb);
  545. si->sock = sock;
  546. si->scm = NULL;
  547. si->msg = msg;
  548. si->size = size;
  549. return sock->ops->sendmsg(iocb, sock, msg, size);
  550. }
  551. static inline int __sock_sendmsg(struct kiocb *iocb, struct socket *sock,
  552. struct msghdr *msg, size_t size)
  553. {
  554. int err = security_socket_sendmsg(sock, msg, size);
  555. return err ?: __sock_sendmsg_nosec(iocb, sock, msg, size);
  556. }
  557. int sock_sendmsg(struct socket *sock, struct msghdr *msg, size_t size)
  558. {
  559. struct kiocb iocb;
  560. struct sock_iocb siocb;
  561. int ret;
  562. init_sync_kiocb(&iocb, NULL);
  563. iocb.private = &siocb;
  564. ret = __sock_sendmsg(&iocb, sock, msg, size);
  565. if (-EIOCBQUEUED == ret)
  566. ret = wait_on_sync_kiocb(&iocb);
  567. return ret;
  568. }
  569. EXPORT_SYMBOL(sock_sendmsg);
  570. static int sock_sendmsg_nosec(struct socket *sock, struct msghdr *msg, size_t size)
  571. {
  572. struct kiocb iocb;
  573. struct sock_iocb siocb;
  574. int ret;
  575. init_sync_kiocb(&iocb, NULL);
  576. iocb.private = &siocb;
  577. ret = __sock_sendmsg_nosec(&iocb, sock, msg, size);
  578. if (-EIOCBQUEUED == ret)
  579. ret = wait_on_sync_kiocb(&iocb);
  580. return ret;
  581. }
  582. int kernel_sendmsg(struct socket *sock, struct msghdr *msg,
  583. struct kvec *vec, size_t num, size_t size)
  584. {
  585. mm_segment_t oldfs = get_fs();
  586. int result;
  587. set_fs(KERNEL_DS);
  588. /*
  589. * the following is safe, since for compiler definitions of kvec and
  590. * iovec are identical, yielding the same in-core layout and alignment
  591. */
  592. msg->msg_iov = (struct iovec *)vec;
  593. msg->msg_iovlen = num;
  594. result = sock_sendmsg(sock, msg, size);
  595. set_fs(oldfs);
  596. return result;
  597. }
  598. EXPORT_SYMBOL(kernel_sendmsg);
  599. /*
  600. * called from sock_recv_timestamp() if sock_flag(sk, SOCK_RCVTSTAMP)
  601. */
  602. void __sock_recv_timestamp(struct msghdr *msg, struct sock *sk,
  603. struct sk_buff *skb)
  604. {
  605. int need_software_tstamp = sock_flag(sk, SOCK_RCVTSTAMP);
  606. struct timespec ts[3];
  607. int empty = 1;
  608. struct skb_shared_hwtstamps *shhwtstamps =
  609. skb_hwtstamps(skb);
  610. /* Race occurred between timestamp enabling and packet
  611. receiving. Fill in the current time for now. */
  612. if (need_software_tstamp && skb->tstamp.tv64 == 0)
  613. __net_timestamp(skb);
  614. if (need_software_tstamp) {
  615. if (!sock_flag(sk, SOCK_RCVTSTAMPNS)) {
  616. struct timeval tv;
  617. skb_get_timestamp(skb, &tv);
  618. put_cmsg(msg, SOL_SOCKET, SCM_TIMESTAMP,
  619. sizeof(tv), &tv);
  620. } else {
  621. skb_get_timestampns(skb, &ts[0]);
  622. put_cmsg(msg, SOL_SOCKET, SCM_TIMESTAMPNS,
  623. sizeof(ts[0]), &ts[0]);
  624. }
  625. }
  626. memset(ts, 0, sizeof(ts));
  627. if (sock_flag(sk, SOCK_TIMESTAMPING_SOFTWARE) &&
  628. ktime_to_timespec_cond(skb->tstamp, ts + 0))
  629. empty = 0;
  630. if (shhwtstamps) {
  631. if (sock_flag(sk, SOCK_TIMESTAMPING_SYS_HARDWARE) &&
  632. ktime_to_timespec_cond(shhwtstamps->syststamp, ts + 1))
  633. empty = 0;
  634. if (sock_flag(sk, SOCK_TIMESTAMPING_RAW_HARDWARE) &&
  635. ktime_to_timespec_cond(shhwtstamps->hwtstamp, ts + 2))
  636. empty = 0;
  637. }
  638. if (!empty)
  639. put_cmsg(msg, SOL_SOCKET,
  640. SCM_TIMESTAMPING, sizeof(ts), &ts);
  641. }
  642. EXPORT_SYMBOL_GPL(__sock_recv_timestamp);
  643. void __sock_recv_wifi_status(struct msghdr *msg, struct sock *sk,
  644. struct sk_buff *skb)
  645. {
  646. int ack;
  647. if (!sock_flag(sk, SOCK_WIFI_STATUS))
  648. return;
  649. if (!skb->wifi_acked_valid)
  650. return;
  651. ack = skb->wifi_acked;
  652. put_cmsg(msg, SOL_SOCKET, SCM_WIFI_STATUS, sizeof(ack), &ack);
  653. }
  654. EXPORT_SYMBOL_GPL(__sock_recv_wifi_status);
  655. static inline void sock_recv_drops(struct msghdr *msg, struct sock *sk,
  656. struct sk_buff *skb)
  657. {
  658. if (sock_flag(sk, SOCK_RXQ_OVFL) && skb && skb->dropcount)
  659. put_cmsg(msg, SOL_SOCKET, SO_RXQ_OVFL,
  660. sizeof(__u32), &skb->dropcount);
  661. }
  662. void __sock_recv_ts_and_drops(struct msghdr *msg, struct sock *sk,
  663. struct sk_buff *skb)
  664. {
  665. sock_recv_timestamp(msg, sk, skb);
  666. sock_recv_drops(msg, sk, skb);
  667. }
  668. EXPORT_SYMBOL_GPL(__sock_recv_ts_and_drops);
  669. static inline int __sock_recvmsg_nosec(struct kiocb *iocb, struct socket *sock,
  670. struct msghdr *msg, size_t size, int flags)
  671. {
  672. struct sock_iocb *si = kiocb_to_siocb(iocb);
  673. si->sock = sock;
  674. si->scm = NULL;
  675. si->msg = msg;
  676. si->size = size;
  677. si->flags = flags;
  678. return sock->ops->recvmsg(iocb, sock, msg, size, flags);
  679. }
  680. static inline int __sock_recvmsg(struct kiocb *iocb, struct socket *sock,
  681. struct msghdr *msg, size_t size, int flags)
  682. {
  683. int err = security_socket_recvmsg(sock, msg, size, flags);
  684. return err ?: __sock_recvmsg_nosec(iocb, sock, msg, size, flags);
  685. }
  686. int sock_recvmsg(struct socket *sock, struct msghdr *msg,
  687. size_t size, int flags)
  688. {
  689. struct kiocb iocb;
  690. struct sock_iocb siocb;
  691. int ret;
  692. init_sync_kiocb(&iocb, NULL);
  693. iocb.private = &siocb;
  694. ret = __sock_recvmsg(&iocb, sock, msg, size, flags);
  695. if (-EIOCBQUEUED == ret)
  696. ret = wait_on_sync_kiocb(&iocb);
  697. return ret;
  698. }
  699. EXPORT_SYMBOL(sock_recvmsg);
  700. static int sock_recvmsg_nosec(struct socket *sock, struct msghdr *msg,
  701. size_t size, int flags)
  702. {
  703. struct kiocb iocb;
  704. struct sock_iocb siocb;
  705. int ret;
  706. init_sync_kiocb(&iocb, NULL);
  707. iocb.private = &siocb;
  708. ret = __sock_recvmsg_nosec(&iocb, sock, msg, size, flags);
  709. if (-EIOCBQUEUED == ret)
  710. ret = wait_on_sync_kiocb(&iocb);
  711. return ret;
  712. }
  713. /**
  714. * kernel_recvmsg - Receive a message from a socket (kernel space)
  715. * @sock: The socket to receive the message from
  716. * @msg: Received message
  717. * @vec: Input s/g array for message data
  718. * @num: Size of input s/g array
  719. * @size: Number of bytes to read
  720. * @flags: Message flags (MSG_DONTWAIT, etc...)
  721. *
  722. * On return the msg structure contains the scatter/gather array passed in the
  723. * vec argument. The array is modified so that it consists of the unfilled
  724. * portion of the original array.
  725. *
  726. * The returned value is the total number of bytes received, or an error.
  727. */
  728. int kernel_recvmsg(struct socket *sock, struct msghdr *msg,
  729. struct kvec *vec, size_t num, size_t size, int flags)
  730. {
  731. mm_segment_t oldfs = get_fs();
  732. int result;
  733. set_fs(KERNEL_DS);
  734. /*
  735. * the following is safe, since for compiler definitions of kvec and
  736. * iovec are identical, yielding the same in-core layout and alignment
  737. */
  738. msg->msg_iov = (struct iovec *)vec, msg->msg_iovlen = num;
  739. result = sock_recvmsg(sock, msg, size, flags);
  740. set_fs(oldfs);
  741. return result;
  742. }
  743. EXPORT_SYMBOL(kernel_recvmsg);
  744. static ssize_t sock_sendpage(struct file *file, struct page *page,
  745. int offset, size_t size, loff_t *ppos, int more)
  746. {
  747. struct socket *sock;
  748. int flags;
  749. sock = file->private_data;
  750. flags = (file->f_flags & O_NONBLOCK) ? MSG_DONTWAIT : 0;
  751. /* more is a combination of MSG_MORE and MSG_SENDPAGE_NOTLAST */
  752. flags |= more;
  753. return kernel_sendpage(sock, page, offset, size, flags);
  754. }
  755. static ssize_t sock_splice_read(struct file *file, loff_t *ppos,
  756. struct pipe_inode_info *pipe, size_t len,
  757. unsigned int flags)
  758. {
  759. struct socket *sock = file->private_data;
  760. if (unlikely(!sock->ops->splice_read))
  761. return -EINVAL;
  762. return sock->ops->splice_read(sock, ppos, pipe, len, flags);
  763. }
  764. static struct sock_iocb *alloc_sock_iocb(struct kiocb *iocb,
  765. struct sock_iocb *siocb)
  766. {
  767. if (!is_sync_kiocb(iocb))
  768. BUG();
  769. siocb->kiocb = iocb;
  770. iocb->private = siocb;
  771. return siocb;
  772. }
  773. static ssize_t do_sock_read(struct msghdr *msg, struct kiocb *iocb,
  774. struct file *file, const struct iovec *iov,
  775. unsigned long nr_segs)
  776. {
  777. struct socket *sock = file->private_data;
  778. size_t size = 0;
  779. int i;
  780. for (i = 0; i < nr_segs; i++)
  781. size += iov[i].iov_len;
  782. msg->msg_name = NULL;
  783. msg->msg_namelen = 0;
  784. msg->msg_control = NULL;
  785. msg->msg_controllen = 0;
  786. msg->msg_iov = (struct iovec *)iov;
  787. msg->msg_iovlen = nr_segs;
  788. msg->msg_flags = (file->f_flags & O_NONBLOCK) ? MSG_DONTWAIT : 0;
  789. return __sock_recvmsg(iocb, sock, msg, size, msg->msg_flags);
  790. }
  791. static ssize_t sock_aio_read(struct kiocb *iocb, const struct iovec *iov,
  792. unsigned long nr_segs, loff_t pos)
  793. {
  794. struct sock_iocb siocb, *x;
  795. if (pos != 0)
  796. return -ESPIPE;
  797. if (iocb->ki_nbytes == 0) /* Match SYS5 behaviour */
  798. return 0;
  799. x = alloc_sock_iocb(iocb, &siocb);
  800. if (!x)
  801. return -ENOMEM;
  802. return do_sock_read(&x->async_msg, iocb, iocb->ki_filp, iov, nr_segs);
  803. }
  804. static ssize_t do_sock_write(struct msghdr *msg, struct kiocb *iocb,
  805. struct file *file, const struct iovec *iov,
  806. unsigned long nr_segs)
  807. {
  808. struct socket *sock = file->private_data;
  809. size_t size = 0;
  810. int i;
  811. for (i = 0; i < nr_segs; i++)
  812. size += iov[i].iov_len;
  813. msg->msg_name = NULL;
  814. msg->msg_namelen = 0;
  815. msg->msg_control = NULL;
  816. msg->msg_controllen = 0;
  817. msg->msg_iov = (struct iovec *)iov;
  818. msg->msg_iovlen = nr_segs;
  819. msg->msg_flags = (file->f_flags & O_NONBLOCK) ? MSG_DONTWAIT : 0;
  820. if (sock->type == SOCK_SEQPACKET)
  821. msg->msg_flags |= MSG_EOR;
  822. return __sock_sendmsg(iocb, sock, msg, size);
  823. }
  824. static ssize_t sock_aio_write(struct kiocb *iocb, const struct iovec *iov,
  825. unsigned long nr_segs, loff_t pos)
  826. {
  827. struct sock_iocb siocb, *x;
  828. if (pos != 0)
  829. return -ESPIPE;
  830. x = alloc_sock_iocb(iocb, &siocb);
  831. if (!x)
  832. return -ENOMEM;
  833. return do_sock_write(&x->async_msg, iocb, iocb->ki_filp, iov, nr_segs);
  834. }
  835. /*
  836. * Atomic setting of ioctl hooks to avoid race
  837. * with module unload.
  838. */
  839. static DEFINE_MUTEX(br_ioctl_mutex);
  840. static int (*br_ioctl_hook) (struct net *, unsigned int cmd, void __user *arg);
  841. void brioctl_set(int (*hook) (struct net *, unsigned int, void __user *))
  842. {
  843. mutex_lock(&br_ioctl_mutex);
  844. br_ioctl_hook = hook;
  845. mutex_unlock(&br_ioctl_mutex);
  846. }
  847. EXPORT_SYMBOL(brioctl_set);
  848. static DEFINE_MUTEX(vlan_ioctl_mutex);
  849. static int (*vlan_ioctl_hook) (struct net *, void __user *arg);
  850. void vlan_ioctl_set(int (*hook) (struct net *, void __user *))
  851. {
  852. mutex_lock(&vlan_ioctl_mutex);
  853. vlan_ioctl_hook = hook;
  854. mutex_unlock(&vlan_ioctl_mutex);
  855. }
  856. EXPORT_SYMBOL(vlan_ioctl_set);
  857. static DEFINE_MUTEX(dlci_ioctl_mutex);
  858. static int (*dlci_ioctl_hook) (unsigned int, void __user *);
  859. void dlci_ioctl_set(int (*hook) (unsigned int, void __user *))
  860. {
  861. mutex_lock(&dlci_ioctl_mutex);
  862. dlci_ioctl_hook = hook;
  863. mutex_unlock(&dlci_ioctl_mutex);
  864. }
  865. EXPORT_SYMBOL(dlci_ioctl_set);
  866. static long sock_do_ioctl(struct net *net, struct socket *sock,
  867. unsigned int cmd, unsigned long arg)
  868. {
  869. int err;
  870. void __user *argp = (void __user *)arg;
  871. err = sock->ops->ioctl(sock, cmd, arg);
  872. /*
  873. * If this ioctl is unknown try to hand it down
  874. * to the NIC driver.
  875. */
  876. if (err == -ENOIOCTLCMD)
  877. err = dev_ioctl(net, cmd, argp);
  878. return err;
  879. }
  880. /*
  881. * With an ioctl, arg may well be a user mode pointer, but we don't know
  882. * what to do with it - that's up to the protocol still.
  883. */
  884. static long sock_ioctl(struct file *file, unsigned cmd, unsigned long arg)
  885. {
  886. struct socket *sock;
  887. struct sock *sk;
  888. void __user *argp = (void __user *)arg;
  889. int pid, err;
  890. struct net *net;
  891. sock = file->private_data;
  892. sk = sock->sk;
  893. net = sock_net(sk);
  894. if (cmd >= SIOCDEVPRIVATE && cmd <= (SIOCDEVPRIVATE + 15)) {
  895. err = dev_ioctl(net, cmd, argp);
  896. } else
  897. #ifdef CONFIG_WEXT_CORE
  898. if (cmd >= SIOCIWFIRST && cmd <= SIOCIWLAST) {
  899. err = dev_ioctl(net, cmd, argp);
  900. } else
  901. #endif
  902. switch (cmd) {
  903. case FIOSETOWN:
  904. case SIOCSPGRP:
  905. err = -EFAULT;
  906. if (get_user(pid, (int __user *)argp))
  907. break;
  908. err = f_setown(sock->file, pid, 1);
  909. break;
  910. case FIOGETOWN:
  911. case SIOCGPGRP:
  912. err = put_user(f_getown(sock->file),
  913. (int __user *)argp);
  914. break;
  915. case SIOCGIFBR:
  916. case SIOCSIFBR:
  917. case SIOCBRADDBR:
  918. case SIOCBRDELBR:
  919. err = -ENOPKG;
  920. if (!br_ioctl_hook)
  921. request_module("bridge");
  922. mutex_lock(&br_ioctl_mutex);
  923. if (br_ioctl_hook)
  924. err = br_ioctl_hook(net, cmd, argp);
  925. mutex_unlock(&br_ioctl_mutex);
  926. break;
  927. case SIOCGIFVLAN:
  928. case SIOCSIFVLAN:
  929. err = -ENOPKG;
  930. if (!vlan_ioctl_hook)
  931. request_module("8021q");
  932. mutex_lock(&vlan_ioctl_mutex);
  933. if (vlan_ioctl_hook)
  934. err = vlan_ioctl_hook(net, argp);
  935. mutex_unlock(&vlan_ioctl_mutex);
  936. break;
  937. case SIOCADDDLCI:
  938. case SIOCDELDLCI:
  939. err = -ENOPKG;
  940. if (!dlci_ioctl_hook)
  941. request_module("dlci");
  942. mutex_lock(&dlci_ioctl_mutex);
  943. if (dlci_ioctl_hook)
  944. err = dlci_ioctl_hook(cmd, argp);
  945. mutex_unlock(&dlci_ioctl_mutex);
  946. break;
  947. default:
  948. err = sock_do_ioctl(net, sock, cmd, arg);
  949. break;
  950. }
  951. return err;
  952. }
  953. int sock_create_lite(int family, int type, int protocol, struct socket **res)
  954. {
  955. int err;
  956. struct socket *sock = NULL;
  957. err = security_socket_create(family, type, protocol, 1);
  958. if (err)
  959. goto out;
  960. sock = sock_alloc();
  961. if (!sock) {
  962. err = -ENOMEM;
  963. goto out;
  964. }
  965. sock->type = type;
  966. err = security_socket_post_create(sock, family, type, protocol, 1);
  967. if (err)
  968. goto out_release;
  969. out:
  970. *res = sock;
  971. return err;
  972. out_release:
  973. sock_release(sock);
  974. sock = NULL;
  975. goto out;
  976. }
  977. EXPORT_SYMBOL(sock_create_lite);
  978. /* No kernel lock held - perfect */
  979. static unsigned int sock_poll(struct file *file, poll_table *wait)
  980. {
  981. unsigned int busy_flag = 0;
  982. struct socket *sock;
  983. /*
  984. * We can't return errors to poll, so it's either yes or no.
  985. */
  986. sock = file->private_data;
  987. if (sk_can_busy_loop(sock->sk)) {
  988. /* this socket can poll_ll so tell the system call */
  989. busy_flag = POLL_BUSY_LOOP;
  990. /* once, only if requested by syscall */
  991. if (wait && (wait->_key & POLL_BUSY_LOOP))
  992. sk_busy_loop(sock->sk, 1);
  993. }
  994. return busy_flag | sock->ops->poll(file, sock, wait);
  995. }
  996. static int sock_mmap(struct file *file, struct vm_area_struct *vma)
  997. {
  998. struct socket *sock = file->private_data;
  999. return sock->ops->mmap(file, sock, vma);
  1000. }
  1001. static int sock_close(struct inode *inode, struct file *filp)
  1002. {
  1003. sock_release(SOCKET_I(inode));
  1004. return 0;
  1005. }
  1006. /*
  1007. * Update the socket async list
  1008. *
  1009. * Fasync_list locking strategy.
  1010. *
  1011. * 1. fasync_list is modified only under process context socket lock
  1012. * i.e. under semaphore.
  1013. * 2. fasync_list is used under read_lock(&sk->sk_callback_lock)
  1014. * or under socket lock
  1015. */
  1016. static int sock_fasync(int fd, struct file *filp, int on)
  1017. {
  1018. struct socket *sock = filp->private_data;
  1019. struct sock *sk = sock->sk;
  1020. struct socket_wq *wq;
  1021. if (sk == NULL)
  1022. return -EINVAL;
  1023. lock_sock(sk);
  1024. wq = rcu_dereference_protected(sock->wq, sock_owned_by_user(sk));
  1025. fasync_helper(fd, filp, on, &wq->fasync_list);
  1026. if (!wq->fasync_list)
  1027. sock_reset_flag(sk, SOCK_FASYNC);
  1028. else
  1029. sock_set_flag(sk, SOCK_FASYNC);
  1030. release_sock(sk);
  1031. return 0;
  1032. }
  1033. /* This function may be called only under socket lock or callback_lock or rcu_lock */
  1034. int sock_wake_async(struct socket *sock, int how, int band)
  1035. {
  1036. struct socket_wq *wq;
  1037. if (!sock)
  1038. return -1;
  1039. rcu_read_lock();
  1040. wq = rcu_dereference(sock->wq);
  1041. if (!wq || !wq->fasync_list) {
  1042. rcu_read_unlock();
  1043. return -1;
  1044. }
  1045. switch (how) {
  1046. case SOCK_WAKE_WAITD:
  1047. if (test_bit(SOCK_ASYNC_WAITDATA, &sock->flags))
  1048. break;
  1049. goto call_kill;
  1050. case SOCK_WAKE_SPACE:
  1051. if (!test_and_clear_bit(SOCK_ASYNC_NOSPACE, &sock->flags))
  1052. break;
  1053. /* fall through */
  1054. case SOCK_WAKE_IO:
  1055. call_kill:
  1056. kill_fasync(&wq->fasync_list, SIGIO, band);
  1057. break;
  1058. case SOCK_WAKE_URG:
  1059. kill_fasync(&wq->fasync_list, SIGURG, band);
  1060. }
  1061. rcu_read_unlock();
  1062. return 0;
  1063. }
  1064. EXPORT_SYMBOL(sock_wake_async);
  1065. int __sock_create(struct net *net, int family, int type, int protocol,
  1066. struct socket **res, int kern)
  1067. {
  1068. int err;
  1069. struct socket *sock;
  1070. const struct net_proto_family *pf;
  1071. /*
  1072. * Check protocol is in range
  1073. */
  1074. if (family < 0 || family >= NPROTO)
  1075. return -EAFNOSUPPORT;
  1076. if (type < 0 || type >= SOCK_MAX)
  1077. return -EINVAL;
  1078. /* Compatibility.
  1079. This uglymoron is moved from INET layer to here to avoid
  1080. deadlock in module load.
  1081. */
  1082. if (family == PF_INET && type == SOCK_PACKET) {
  1083. static int warned;
  1084. if (!warned) {
  1085. warned = 1;
  1086. printk(KERN_INFO "%s uses obsolete (PF_INET,SOCK_PACKET)\n",
  1087. current->comm);
  1088. }
  1089. family = PF_PACKET;
  1090. }
  1091. err = security_socket_create(family, type, protocol, kern);
  1092. if (err)
  1093. return err;
  1094. /*
  1095. * Allocate the socket and allow the family to set things up. if
  1096. * the protocol is 0, the family is instructed to select an appropriate
  1097. * default.
  1098. */
  1099. sock = sock_alloc();
  1100. if (!sock) {
  1101. net_warn_ratelimited("socket: no more sockets\n");
  1102. return -ENFILE; /* Not exactly a match, but its the
  1103. closest posix thing */
  1104. }
  1105. sock->type = type;
  1106. #ifdef CONFIG_MODULES
  1107. /* Attempt to load a protocol module if the find failed.
  1108. *
  1109. * 12/09/1996 Marcin: But! this makes REALLY only sense, if the user
  1110. * requested real, full-featured networking support upon configuration.
  1111. * Otherwise module support will break!
  1112. */
  1113. if (rcu_access_pointer(net_families[family]) == NULL)
  1114. request_module("net-pf-%d", family);
  1115. #endif
  1116. rcu_read_lock();
  1117. pf = rcu_dereference(net_families[family]);
  1118. err = -EAFNOSUPPORT;
  1119. if (!pf)
  1120. goto out_release;
  1121. /*
  1122. * We will call the ->create function, that possibly is in a loadable
  1123. * module, so we have to bump that loadable module refcnt first.
  1124. */
  1125. if (!try_module_get(pf->owner))
  1126. goto out_release;
  1127. /* Now protected by module ref count */
  1128. rcu_read_unlock();
  1129. err = pf->create(net, sock, protocol, kern);
  1130. if (err < 0)
  1131. goto out_module_put;
  1132. /*
  1133. * Now to bump the refcnt of the [loadable] module that owns this
  1134. * socket at sock_release time we decrement its refcnt.
  1135. */
  1136. if (!try_module_get(sock->ops->owner))
  1137. goto out_module_busy;
  1138. /*
  1139. * Now that we're done with the ->create function, the [loadable]
  1140. * module can have its refcnt decremented
  1141. */
  1142. module_put(pf->owner);
  1143. err = security_socket_post_create(sock, family, type, protocol, kern);
  1144. if (err)
  1145. goto out_sock_release;
  1146. *res = sock;
  1147. return 0;
  1148. out_module_busy:
  1149. err = -EAFNOSUPPORT;
  1150. out_module_put:
  1151. sock->ops = NULL;
  1152. module_put(pf->owner);
  1153. out_sock_release:
  1154. sock_release(sock);
  1155. return err;
  1156. out_release:
  1157. rcu_read_unlock();
  1158. goto out_sock_release;
  1159. }
  1160. EXPORT_SYMBOL(__sock_create);
  1161. int sock_create(int family, int type, int protocol, struct socket **res)
  1162. {
  1163. return __sock_create(current->nsproxy->net_ns, family, type, protocol, res, 0);
  1164. }
  1165. EXPORT_SYMBOL(sock_create);
  1166. int sock_create_kern(int family, int type, int protocol, struct socket **res)
  1167. {
  1168. return __sock_create(&init_net, family, type, protocol, res, 1);
  1169. }
  1170. EXPORT_SYMBOL(sock_create_kern);
  1171. SYSCALL_DEFINE3(socket, int, family, int, type, int, protocol)
  1172. {
  1173. int retval;
  1174. struct socket *sock;
  1175. int flags;
  1176. /* Check the SOCK_* constants for consistency. */
  1177. BUILD_BUG_ON(SOCK_CLOEXEC != O_CLOEXEC);
  1178. BUILD_BUG_ON((SOCK_MAX | SOCK_TYPE_MASK) != SOCK_TYPE_MASK);
  1179. BUILD_BUG_ON(SOCK_CLOEXEC & SOCK_TYPE_MASK);
  1180. BUILD_BUG_ON(SOCK_NONBLOCK & SOCK_TYPE_MASK);
  1181. flags = type & ~SOCK_TYPE_MASK;
  1182. if (flags & ~(SOCK_CLOEXEC | SOCK_NONBLOCK))
  1183. return -EINVAL;
  1184. type &= SOCK_TYPE_MASK;
  1185. if (SOCK_NONBLOCK != O_NONBLOCK && (flags & SOCK_NONBLOCK))
  1186. flags = (flags & ~SOCK_NONBLOCK) | O_NONBLOCK;
  1187. retval = sock_create(family, type, protocol, &sock);
  1188. if (retval < 0)
  1189. goto out;
  1190. retval = sock_map_fd(sock, flags & (O_CLOEXEC | O_NONBLOCK));
  1191. if (retval < 0)
  1192. goto out_release;
  1193. out:
  1194. /* It may be already another descriptor 8) Not kernel problem. */
  1195. return retval;
  1196. out_release:
  1197. sock_release(sock);
  1198. return retval;
  1199. }
  1200. /*
  1201. * Create a pair of connected sockets.
  1202. */
  1203. SYSCALL_DEFINE4(socketpair, int, family, int, type, int, protocol,
  1204. int __user *, usockvec)
  1205. {
  1206. struct socket *sock1, *sock2;
  1207. int fd1, fd2, err;
  1208. struct file *newfile1, *newfile2;
  1209. int flags;
  1210. flags = type & ~SOCK_TYPE_MASK;
  1211. if (flags & ~(SOCK_CLOEXEC | SOCK_NONBLOCK))
  1212. return -EINVAL;
  1213. type &= SOCK_TYPE_MASK;
  1214. if (SOCK_NONBLOCK != O_NONBLOCK && (flags & SOCK_NONBLOCK))
  1215. flags = (flags & ~SOCK_NONBLOCK) | O_NONBLOCK;
  1216. /*
  1217. * Obtain the first socket and check if the underlying protocol
  1218. * supports the socketpair call.
  1219. */
  1220. err = sock_create(family, type, protocol, &sock1);
  1221. if (err < 0)
  1222. goto out;
  1223. err = sock_create(family, type, protocol, &sock2);
  1224. if (err < 0)
  1225. goto out_release_1;
  1226. err = sock1->ops->socketpair(sock1, sock2);
  1227. if (err < 0)
  1228. goto out_release_both;
  1229. fd1 = get_unused_fd_flags(flags);
  1230. if (unlikely(fd1 < 0)) {
  1231. err = fd1;
  1232. goto out_release_both;
  1233. }
  1234. fd2 = get_unused_fd_flags(flags);
  1235. if (unlikely(fd2 < 0)) {
  1236. err = fd2;
  1237. put_unused_fd(fd1);
  1238. goto out_release_both;
  1239. }
  1240. newfile1 = sock_alloc_file(sock1, flags, NULL);
  1241. if (unlikely(IS_ERR(newfile1))) {
  1242. err = PTR_ERR(newfile1);
  1243. put_unused_fd(fd1);
  1244. put_unused_fd(fd2);
  1245. goto out_release_both;
  1246. }
  1247. newfile2 = sock_alloc_file(sock2, flags, NULL);
  1248. if (IS_ERR(newfile2)) {
  1249. err = PTR_ERR(newfile2);
  1250. fput(newfile1);
  1251. put_unused_fd(fd1);
  1252. put_unused_fd(fd2);
  1253. sock_release(sock2);
  1254. goto out;
  1255. }
  1256. audit_fd_pair(fd1, fd2);
  1257. fd_install(fd1, newfile1);
  1258. fd_install(fd2, newfile2);
  1259. /* fd1 and fd2 may be already another descriptors.
  1260. * Not kernel problem.
  1261. */
  1262. err = put_user(fd1, &usockvec[0]);
  1263. if (!err)
  1264. err = put_user(fd2, &usockvec[1]);
  1265. if (!err)
  1266. return 0;
  1267. sys_close(fd2);
  1268. sys_close(fd1);
  1269. return err;
  1270. out_release_both:
  1271. sock_release(sock2);
  1272. out_release_1:
  1273. sock_release(sock1);
  1274. out:
  1275. return err;
  1276. }
  1277. /*
  1278. * Bind a name to a socket. Nothing much to do here since it's
  1279. * the protocol's responsibility to handle the local address.
  1280. *
  1281. * We move the socket address to kernel space before we call
  1282. * the protocol layer (having also checked the address is ok).
  1283. */
  1284. SYSCALL_DEFINE3(bind, int, fd, struct sockaddr __user *, umyaddr, int, addrlen)
  1285. {
  1286. struct socket *sock;
  1287. struct sockaddr_storage address;
  1288. int err, fput_needed;
  1289. sock = sockfd_lookup_light(fd, &err, &fput_needed);
  1290. if (sock) {
  1291. err = move_addr_to_kernel(umyaddr, addrlen, &address);
  1292. if (err >= 0) {
  1293. err = security_socket_bind(sock,
  1294. (struct sockaddr *)&address,
  1295. addrlen);
  1296. if (!err)
  1297. err = sock->ops->bind(sock,
  1298. (struct sockaddr *)
  1299. &address, addrlen);
  1300. }
  1301. fput_light(sock->file, fput_needed);
  1302. }
  1303. return err;
  1304. }
  1305. /*
  1306. * Perform a listen. Basically, we allow the protocol to do anything
  1307. * necessary for a listen, and if that works, we mark the socket as
  1308. * ready for listening.
  1309. */
  1310. SYSCALL_DEFINE2(listen, int, fd, int, backlog)
  1311. {
  1312. struct socket *sock;
  1313. int err, fput_needed;
  1314. int somaxconn;
  1315. sock = sockfd_lookup_light(fd, &err, &fput_needed);
  1316. if (sock) {
  1317. somaxconn = sock_net(sock->sk)->core.sysctl_somaxconn;
  1318. if ((unsigned int)backlog > somaxconn)
  1319. backlog = somaxconn;
  1320. err = security_socket_listen(sock, backlog);
  1321. if (!err)
  1322. err = sock->ops->listen(sock, backlog);
  1323. fput_light(sock->file, fput_needed);
  1324. }
  1325. return err;
  1326. }
  1327. /*
  1328. * For accept, we attempt to create a new socket, set up the link
  1329. * with the client, wake up the client, then return the new
  1330. * connected fd. We collect the address of the connector in kernel
  1331. * space and move it to user at the very end. This is unclean because
  1332. * we open the socket then return an error.
  1333. *
  1334. * 1003.1g adds the ability to recvmsg() to query connection pending
  1335. * status to recvmsg. We need to add that support in a way thats
  1336. * clean when we restucture accept also.
  1337. */
  1338. SYSCALL_DEFINE4(accept4, int, fd, struct sockaddr __user *, upeer_sockaddr,
  1339. int __user *, upeer_addrlen, int, flags)
  1340. {
  1341. struct socket *sock, *newsock;
  1342. struct file *newfile;
  1343. int err, len, newfd, fput_needed;
  1344. struct sockaddr_storage address;
  1345. if (flags & ~(SOCK_CLOEXEC | SOCK_NONBLOCK))
  1346. return -EINVAL;
  1347. if (SOCK_NONBLOCK != O_NONBLOCK && (flags & SOCK_NONBLOCK))
  1348. flags = (flags & ~SOCK_NONBLOCK) | O_NONBLOCK;
  1349. sock = sockfd_lookup_light(fd, &err, &fput_needed);
  1350. if (!sock)
  1351. goto out;
  1352. err = -ENFILE;
  1353. newsock = sock_alloc();
  1354. if (!newsock)
  1355. goto out_put;
  1356. newsock->type = sock->type;
  1357. newsock->ops = sock->ops;
  1358. /*
  1359. * We don't need try_module_get here, as the listening socket (sock)
  1360. * has the protocol module (sock->ops->owner) held.
  1361. */
  1362. __module_get(newsock->ops->owner);
  1363. newfd = get_unused_fd_flags(flags);
  1364. if (unlikely(newfd < 0)) {
  1365. err = newfd;
  1366. sock_release(newsock);
  1367. goto out_put;
  1368. }
  1369. newfile = sock_alloc_file(newsock, flags, sock->sk->sk_prot_creator->name);
  1370. if (unlikely(IS_ERR(newfile))) {
  1371. err = PTR_ERR(newfile);
  1372. put_unused_fd(newfd);
  1373. sock_release(newsock);
  1374. goto out_put;
  1375. }
  1376. err = security_socket_accept(sock, newsock);
  1377. if (err)
  1378. goto out_fd;
  1379. err = sock->ops->accept(sock, newsock, sock->file->f_flags);
  1380. if (err < 0)
  1381. goto out_fd;
  1382. if (upeer_sockaddr) {
  1383. if (newsock->ops->getname(newsock, (struct sockaddr *)&address,
  1384. &len, 2) < 0) {
  1385. err = -ECONNABORTED;
  1386. goto out_fd;
  1387. }
  1388. err = move_addr_to_user(&address,
  1389. len, upeer_sockaddr, upeer_addrlen);
  1390. if (err < 0)
  1391. goto out_fd;
  1392. }
  1393. /* File flags are not inherited via accept() unlike another OSes. */
  1394. fd_install(newfd, newfile);
  1395. err = newfd;
  1396. out_put:
  1397. fput_light(sock->file, fput_needed);
  1398. out:
  1399. return err;
  1400. out_fd:
  1401. fput(newfile);
  1402. put_unused_fd(newfd);
  1403. goto out_put;
  1404. }
  1405. SYSCALL_DEFINE3(accept, int, fd, struct sockaddr __user *, upeer_sockaddr,
  1406. int __user *, upeer_addrlen)
  1407. {
  1408. return sys_accept4(fd, upeer_sockaddr, upeer_addrlen, 0);
  1409. }
  1410. /*
  1411. * Attempt to connect to a socket with the server address. The address
  1412. * is in user space so we verify it is OK and move it to kernel space.
  1413. *
  1414. * For 1003.1g we need to add clean support for a bind to AF_UNSPEC to
  1415. * break bindings
  1416. *
  1417. * NOTE: 1003.1g draft 6.3 is broken with respect to AX.25/NetROM and
  1418. * other SEQPACKET protocols that take time to connect() as it doesn't
  1419. * include the -EINPROGRESS status for such sockets.
  1420. */
  1421. SYSCALL_DEFINE3(connect, int, fd, struct sockaddr __user *, uservaddr,
  1422. int, addrlen)
  1423. {
  1424. struct socket *sock;
  1425. struct sockaddr_storage address;
  1426. int err, fput_needed;
  1427. sock = sockfd_lookup_light(fd, &err, &fput_needed);
  1428. if (!sock)
  1429. goto out;
  1430. err = move_addr_to_kernel(uservaddr, addrlen, &address);
  1431. if (err < 0)
  1432. goto out_put;
  1433. err =
  1434. security_socket_connect(sock, (struct sockaddr *)&address, addrlen);
  1435. if (err)
  1436. goto out_put;
  1437. err = sock->ops->connect(sock, (struct sockaddr *)&address, addrlen,
  1438. sock->file->f_flags);
  1439. out_put:
  1440. fput_light(sock->file, fput_needed);
  1441. out:
  1442. return err;
  1443. }
  1444. /*
  1445. * Get the local address ('name') of a socket object. Move the obtained
  1446. * name to user space.
  1447. */
  1448. SYSCALL_DEFINE3(getsockname, int, fd, struct sockaddr __user *, usockaddr,
  1449. int __user *, usockaddr_len)
  1450. {
  1451. struct socket *sock;
  1452. struct sockaddr_storage address;
  1453. int len, err, fput_needed;
  1454. sock = sockfd_lookup_light(fd, &err, &fput_needed);
  1455. if (!sock)
  1456. goto out;
  1457. err = security_socket_getsockname(sock);
  1458. if (err)
  1459. goto out_put;
  1460. err = sock->ops->getname(sock, (struct sockaddr *)&address, &len, 0);
  1461. if (err)
  1462. goto out_put;
  1463. err = move_addr_to_user(&address, len, usockaddr, usockaddr_len);
  1464. out_put:
  1465. fput_light(sock->file, fput_needed);
  1466. out:
  1467. return err;
  1468. }
  1469. /*
  1470. * Get the remote address ('name') of a socket object. Move the obtained
  1471. * name to user space.
  1472. */
  1473. SYSCALL_DEFINE3(getpeername, int, fd, struct sockaddr __user *, usockaddr,
  1474. int __user *, usockaddr_len)
  1475. {
  1476. struct socket *sock;
  1477. struct sockaddr_storage address;
  1478. int len, err, fput_needed;
  1479. sock = sockfd_lookup_light(fd, &err, &fput_needed);
  1480. if (sock != NULL) {
  1481. err = security_socket_getpeername(sock);
  1482. if (err) {
  1483. fput_light(sock->file, fput_needed);
  1484. return err;
  1485. }
  1486. err =
  1487. sock->ops->getname(sock, (struct sockaddr *)&address, &len,
  1488. 1);
  1489. if (!err)
  1490. err = move_addr_to_user(&address, len, usockaddr,
  1491. usockaddr_len);
  1492. fput_light(sock->file, fput_needed);
  1493. }
  1494. return err;
  1495. }
  1496. /*
  1497. * Send a datagram to a given address. We move the address into kernel
  1498. * space and check the user space data area is readable before invoking
  1499. * the protocol.
  1500. */
  1501. SYSCALL_DEFINE6(sendto, int, fd, void __user *, buff, size_t, len,
  1502. unsigned int, flags, struct sockaddr __user *, addr,
  1503. int, addr_len)
  1504. {
  1505. struct socket *sock;
  1506. struct sockaddr_storage address;
  1507. int err;
  1508. struct msghdr msg;
  1509. struct iovec iov;
  1510. int fput_needed;
  1511. if (len > INT_MAX)
  1512. len = INT_MAX;
  1513. sock = sockfd_lookup_light(fd, &err, &fput_needed);
  1514. if (!sock)
  1515. goto out;
  1516. iov.iov_base = buff;
  1517. iov.iov_len = len;
  1518. msg.msg_name = NULL;
  1519. msg.msg_iov = &iov;
  1520. msg.msg_iovlen = 1;
  1521. msg.msg_control = NULL;
  1522. msg.msg_controllen = 0;
  1523. msg.msg_namelen = 0;
  1524. if (addr) {
  1525. err = move_addr_to_kernel(addr, addr_len, &address);
  1526. if (err < 0)
  1527. goto out_put;
  1528. msg.msg_name = (struct sockaddr *)&address;
  1529. msg.msg_namelen = addr_len;
  1530. }
  1531. if (sock->file->f_flags & O_NONBLOCK)
  1532. flags |= MSG_DONTWAIT;
  1533. msg.msg_flags = flags;
  1534. err = sock_sendmsg(sock, &msg, len);
  1535. out_put:
  1536. fput_light(sock->file, fput_needed);
  1537. out:
  1538. return err;
  1539. }
  1540. /*
  1541. * Send a datagram down a socket.
  1542. */
  1543. SYSCALL_DEFINE4(send, int, fd, void __user *, buff, size_t, len,
  1544. unsigned int, flags)
  1545. {
  1546. return sys_sendto(fd, buff, len, flags, NULL, 0);
  1547. }
  1548. /*
  1549. * Receive a frame from the socket and optionally record the address of the
  1550. * sender. We verify the buffers are writable and if needed move the
  1551. * sender address from kernel to user space.
  1552. */
  1553. SYSCALL_DEFINE6(recvfrom, int, fd, void __user *, ubuf, size_t, size,
  1554. unsigned int, flags, struct sockaddr __user *, addr,
  1555. int __user *, addr_len)
  1556. {
  1557. struct socket *sock;
  1558. struct iovec iov;
  1559. struct msghdr msg;
  1560. struct sockaddr_storage address;
  1561. int err, err2;
  1562. int fput_needed;
  1563. if (size > INT_MAX)
  1564. size = INT_MAX;
  1565. sock = sockfd_lookup_light(fd, &err, &fput_needed);
  1566. if (!sock)
  1567. goto out;
  1568. msg.msg_control = NULL;
  1569. msg.msg_controllen = 0;
  1570. msg.msg_iovlen = 1;
  1571. msg.msg_iov = &iov;
  1572. iov.iov_len = size;
  1573. iov.iov_base = ubuf;
  1574. msg.msg_name = (struct sockaddr *)&address;
  1575. msg.msg_namelen = sizeof(address);
  1576. if (sock->file->f_flags & O_NONBLOCK)
  1577. flags |= MSG_DONTWAIT;
  1578. err = sock_recvmsg(sock, &msg, size, flags);
  1579. if (err >= 0 && addr != NULL) {
  1580. err2 = move_addr_to_user(&address,
  1581. msg.msg_namelen, addr, addr_len);
  1582. if (err2 < 0)
  1583. err = err2;
  1584. }
  1585. fput_light(sock->file, fput_needed);
  1586. out:
  1587. return err;
  1588. }
  1589. /*
  1590. * Receive a datagram from a socket.
  1591. */
  1592. asmlinkage long sys_recv(int fd, void __user *ubuf, size_t size,
  1593. unsigned int flags)
  1594. {
  1595. return sys_recvfrom(fd, ubuf, size, flags, NULL, NULL);
  1596. }
  1597. /*
  1598. * Set a socket option. Because we don't know the option lengths we have
  1599. * to pass the user mode parameter for the protocols to sort out.
  1600. */
  1601. SYSCALL_DEFINE5(setsockopt, int, fd, int, level, int, optname,
  1602. char __user *, optval, int, optlen)
  1603. {
  1604. int err, fput_needed;
  1605. struct socket *sock;
  1606. if (optlen < 0)
  1607. return -EINVAL;
  1608. sock = sockfd_lookup_light(fd, &err, &fput_needed);
  1609. if (sock != NULL) {
  1610. err = security_socket_setsockopt(sock, level, optname);
  1611. if (err)
  1612. goto out_put;
  1613. if (level == SOL_SOCKET)
  1614. err =
  1615. sock_setsockopt(sock, level, optname, optval,
  1616. optlen);
  1617. else
  1618. err =
  1619. sock->ops->setsockopt(sock, level, optname, optval,
  1620. optlen);
  1621. out_put:
  1622. fput_light(sock->file, fput_needed);
  1623. }
  1624. return err;
  1625. }
  1626. /*
  1627. * Get a socket option. Because we don't know the option lengths we have
  1628. * to pass a user mode parameter for the protocols to sort out.
  1629. */
  1630. SYSCALL_DEFINE5(getsockopt, int, fd, int, level, int, optname,
  1631. char __user *, optval, int __user *, optlen)
  1632. {
  1633. int err, fput_needed;
  1634. struct socket *sock;
  1635. sock = sockfd_lookup_light(fd, &err, &fput_needed);
  1636. if (sock != NULL) {
  1637. err = security_socket_getsockopt(sock, level, optname);
  1638. if (err)
  1639. goto out_put;
  1640. if (level == SOL_SOCKET)
  1641. err =
  1642. sock_getsockopt(sock, level, optname, optval,
  1643. optlen);
  1644. else
  1645. err =
  1646. sock->ops->getsockopt(sock, level, optname, optval,
  1647. optlen);
  1648. out_put:
  1649. fput_light(sock->file, fput_needed);
  1650. }
  1651. return err;
  1652. }
  1653. /*
  1654. * Shutdown a socket.
  1655. */
  1656. SYSCALL_DEFINE2(shutdown, int, fd, int, how)
  1657. {
  1658. int err, fput_needed;
  1659. struct socket *sock;
  1660. sock = sockfd_lookup_light(fd, &err, &fput_needed);
  1661. if (sock != NULL) {
  1662. err = security_socket_shutdown(sock, how);
  1663. if (!err)
  1664. err = sock->ops->shutdown(sock, how);
  1665. fput_light(sock->file, fput_needed);
  1666. }
  1667. return err;
  1668. }
  1669. /* A couple of helpful macros for getting the address of the 32/64 bit
  1670. * fields which are the same type (int / unsigned) on our platforms.
  1671. */
  1672. #define COMPAT_MSG(msg, member) ((MSG_CMSG_COMPAT & flags) ? &msg##_compat->member : &msg->member)
  1673. #define COMPAT_NAMELEN(msg) COMPAT_MSG(msg, msg_namelen)
  1674. #define COMPAT_FLAGS(msg) COMPAT_MSG(msg, msg_flags)
  1675. struct used_address {
  1676. struct sockaddr_storage name;
  1677. unsigned int name_len;
  1678. };
  1679. static int copy_msghdr_from_user(struct msghdr *kmsg,
  1680. struct msghdr __user *umsg)
  1681. {
  1682. if (copy_from_user(kmsg, umsg, sizeof(struct msghdr)))
  1683. return -EFAULT;
  1684. if (kmsg->msg_namelen > sizeof(struct sockaddr_storage))
  1685. return -EINVAL;
  1686. return 0;
  1687. }
  1688. static int ___sys_sendmsg(struct socket *sock, struct msghdr __user *msg,
  1689. struct msghdr *msg_sys, unsigned int flags,
  1690. struct used_address *used_address)
  1691. {
  1692. struct compat_msghdr __user *msg_compat =
  1693. (struct compat_msghdr __user *)msg;
  1694. struct sockaddr_storage address;
  1695. struct iovec iovstack[UIO_FASTIOV], *iov = iovstack;
  1696. unsigned char ctl[sizeof(struct cmsghdr) + 20]
  1697. __attribute__ ((aligned(sizeof(__kernel_size_t))));
  1698. /* 20 is size of ipv6_pktinfo */
  1699. unsigned char *ctl_buf = ctl;
  1700. int err, ctl_len, total_len;
  1701. err = -EFAULT;
  1702. if (MSG_CMSG_COMPAT & flags) {
  1703. if (get_compat_msghdr(msg_sys, msg_compat))
  1704. return -EFAULT;
  1705. } else {
  1706. err = copy_msghdr_from_user(msg_sys, msg);
  1707. if (err)
  1708. return err;
  1709. }
  1710. if (msg_sys->msg_iovlen > UIO_FASTIOV) {
  1711. err = -EMSGSIZE;
  1712. if (msg_sys->msg_iovlen > UIO_MAXIOV)
  1713. goto out;
  1714. err = -ENOMEM;
  1715. iov = kmalloc(msg_sys->msg_iovlen * sizeof(struct iovec),
  1716. GFP_KERNEL);
  1717. if (!iov)
  1718. goto out;
  1719. }
  1720. /* This will also move the address data into kernel space */
  1721. if (MSG_CMSG_COMPAT & flags) {
  1722. err = verify_compat_iovec(msg_sys, iov, &address, VERIFY_READ);
  1723. } else
  1724. err = verify_iovec(msg_sys, iov, &address, VERIFY_READ);
  1725. if (err < 0)
  1726. goto out_freeiov;
  1727. total_len = err;
  1728. err = -ENOBUFS;
  1729. if (msg_sys->msg_controllen > INT_MAX)
  1730. goto out_freeiov;
  1731. ctl_len = msg_sys->msg_controllen;
  1732. if ((MSG_CMSG_COMPAT & flags) && ctl_len) {
  1733. err =
  1734. cmsghdr_from_user_compat_to_kern(msg_sys, sock->sk, ctl,
  1735. sizeof(ctl));
  1736. if (err)
  1737. goto out_freeiov;
  1738. ctl_buf = msg_sys->msg_control;
  1739. ctl_len = msg_sys->msg_controllen;
  1740. } else if (ctl_len) {
  1741. if (ctl_len > sizeof(ctl)) {
  1742. ctl_buf = sock_kmalloc(sock->sk, ctl_len, GFP_KERNEL);
  1743. if (ctl_buf == NULL)
  1744. goto out_freeiov;
  1745. }
  1746. err = -EFAULT;
  1747. /*
  1748. * Careful! Before this, msg_sys->msg_control contains a user pointer.
  1749. * Afterwards, it will be a kernel pointer. Thus the compiler-assisted
  1750. * checking falls down on this.
  1751. */
  1752. if (copy_from_user(ctl_buf,
  1753. (void __user __force *)msg_sys->msg_control,
  1754. ctl_len))
  1755. goto out_freectl;
  1756. msg_sys->msg_control = ctl_buf;
  1757. }
  1758. msg_sys->msg_flags = flags;
  1759. if (sock->file->f_flags & O_NONBLOCK)
  1760. msg_sys->msg_flags |= MSG_DONTWAIT;
  1761. /*
  1762. * If this is sendmmsg() and current destination address is same as
  1763. * previously succeeded address, omit asking LSM's decision.
  1764. * used_address->name_len is initialized to UINT_MAX so that the first
  1765. * destination address never matches.
  1766. */
  1767. if (used_address && msg_sys->msg_name &&
  1768. used_address->name_len == msg_sys->msg_namelen &&
  1769. !memcmp(&used_address->name, msg_sys->msg_name,
  1770. used_address->name_len)) {
  1771. err = sock_sendmsg_nosec(sock, msg_sys, total_len);
  1772. goto out_freectl;
  1773. }
  1774. err = sock_sendmsg(sock, msg_sys, total_len);
  1775. /*
  1776. * If this is sendmmsg() and sending to current destination address was
  1777. * successful, remember it.
  1778. */
  1779. if (used_address && err >= 0) {
  1780. used_address->name_len = msg_sys->msg_namelen;
  1781. if (msg_sys->msg_name)
  1782. memcpy(&used_address->name, msg_sys->msg_name,
  1783. used_address->name_len);
  1784. }
  1785. out_freectl:
  1786. if (ctl_buf != ctl)
  1787. sock_kfree_s(sock->sk, ctl_buf, ctl_len);
  1788. out_freeiov:
  1789. if (iov != iovstack)
  1790. kfree(iov);
  1791. out:
  1792. return err;
  1793. }
  1794. /*
  1795. * BSD sendmsg interface
  1796. */
  1797. long __sys_sendmsg(int fd, struct msghdr __user *msg, unsigned flags)
  1798. {
  1799. int fput_needed, err;
  1800. struct msghdr msg_sys;
  1801. struct socket *sock;
  1802. sock = sockfd_lookup_light(fd, &err, &fput_needed);
  1803. if (!sock)
  1804. goto out;
  1805. err = ___sys_sendmsg(sock, msg, &msg_sys, flags, NULL);
  1806. fput_light(sock->file, fput_needed);
  1807. out:
  1808. return err;
  1809. }
  1810. SYSCALL_DEFINE3(sendmsg, int, fd, struct msghdr __user *, msg, unsigned int, flags)
  1811. {
  1812. if (flags & MSG_CMSG_COMPAT)
  1813. return -EINVAL;
  1814. return __sys_sendmsg(fd, msg, flags);
  1815. }
  1816. /*
  1817. * Linux sendmmsg interface
  1818. */
  1819. int __sys_sendmmsg(int fd, struct mmsghdr __user *mmsg, unsigned int vlen,
  1820. unsigned int flags)
  1821. {
  1822. int fput_needed, err, datagrams;
  1823. struct socket *sock;
  1824. struct mmsghdr __user *entry;
  1825. struct compat_mmsghdr __user *compat_entry;
  1826. struct msghdr msg_sys;
  1827. struct used_address used_address;
  1828. if (vlen > UIO_MAXIOV)
  1829. vlen = UIO_MAXIOV;
  1830. datagrams = 0;
  1831. sock = sockfd_lookup_light(fd, &err, &fput_needed);
  1832. if (!sock)
  1833. return err;
  1834. used_address.name_len = UINT_MAX;
  1835. entry = mmsg;
  1836. compat_entry = (struct compat_mmsghdr __user *)mmsg;
  1837. err = 0;
  1838. while (datagrams < vlen) {
  1839. if (MSG_CMSG_COMPAT & flags) {
  1840. err = ___sys_sendmsg(sock, (struct msghdr __user *)compat_entry,
  1841. &msg_sys, flags, &used_address);
  1842. if (err < 0)
  1843. break;
  1844. err = __put_user(err, &compat_entry->msg_len);
  1845. ++compat_entry;
  1846. } else {
  1847. err = ___sys_sendmsg(sock,
  1848. (struct msghdr __user *)entry,
  1849. &msg_sys, flags, &used_address);
  1850. if (err < 0)
  1851. break;
  1852. err = put_user(err, &entry->msg_len);
  1853. ++entry;
  1854. }
  1855. if (err)
  1856. break;
  1857. ++datagrams;
  1858. }
  1859. fput_light(sock->file, fput_needed);
  1860. /* We only return an error if no datagrams were able to be sent */
  1861. if (datagrams != 0)
  1862. return datagrams;
  1863. return err;
  1864. }
  1865. SYSCALL_DEFINE4(sendmmsg, int, fd, struct mmsghdr __user *, mmsg,
  1866. unsigned int, vlen, unsigned int, flags)
  1867. {
  1868. if (flags & MSG_CMSG_COMPAT)
  1869. return -EINVAL;
  1870. return __sys_sendmmsg(fd, mmsg, vlen, flags);
  1871. }
  1872. static int ___sys_recvmsg(struct socket *sock, struct msghdr __user *msg,
  1873. struct msghdr *msg_sys, unsigned int flags, int nosec)
  1874. {
  1875. struct compat_msghdr __user *msg_compat =
  1876. (struct compat_msghdr __user *)msg;
  1877. struct iovec iovstack[UIO_FASTIOV];
  1878. struct iovec *iov = iovstack;
  1879. unsigned long cmsg_ptr;
  1880. int err, total_len, len;
  1881. /* kernel mode address */
  1882. struct sockaddr_storage addr;
  1883. /* user mode address pointers */
  1884. struct sockaddr __user *uaddr;
  1885. int __user *uaddr_len;
  1886. if (MSG_CMSG_COMPAT & flags) {
  1887. if (get_compat_msghdr(msg_sys, msg_compat))
  1888. return -EFAULT;
  1889. } else {
  1890. err = copy_msghdr_from_user(msg_sys, msg);
  1891. if (err)
  1892. return err;
  1893. }
  1894. if (msg_sys->msg_iovlen > UIO_FASTIOV) {
  1895. err = -EMSGSIZE;
  1896. if (msg_sys->msg_iovlen > UIO_MAXIOV)
  1897. goto out;
  1898. err = -ENOMEM;
  1899. iov = kmalloc(msg_sys->msg_iovlen * sizeof(struct iovec),
  1900. GFP_KERNEL);
  1901. if (!iov)
  1902. goto out;
  1903. }
  1904. /*
  1905. * Save the user-mode address (verify_iovec will change the
  1906. * kernel msghdr to use the kernel address space)
  1907. */
  1908. uaddr = (__force void __user *)msg_sys->msg_name;
  1909. uaddr_len = COMPAT_NAMELEN(msg);
  1910. if (MSG_CMSG_COMPAT & flags) {
  1911. err = verify_compat_iovec(msg_sys, iov, &addr, VERIFY_WRITE);
  1912. } else
  1913. err = verify_iovec(msg_sys, iov, &addr, VERIFY_WRITE);
  1914. if (err < 0)
  1915. goto out_freeiov;
  1916. total_len = err;
  1917. cmsg_ptr = (unsigned long)msg_sys->msg_control;
  1918. msg_sys->msg_flags = flags & (MSG_CMSG_CLOEXEC|MSG_CMSG_COMPAT);
  1919. if (sock->file->f_flags & O_NONBLOCK)
  1920. flags |= MSG_DONTWAIT;
  1921. err = (nosec ? sock_recvmsg_nosec : sock_recvmsg)(sock, msg_sys,
  1922. total_len, flags);
  1923. if (err < 0)
  1924. goto out_freeiov;
  1925. len = err;
  1926. if (uaddr != NULL) {
  1927. err = move_addr_to_user(&addr,
  1928. msg_sys->msg_namelen, uaddr,
  1929. uaddr_len);
  1930. if (err < 0)
  1931. goto out_freeiov;
  1932. }
  1933. err = __put_user((msg_sys->msg_flags & ~MSG_CMSG_COMPAT),
  1934. COMPAT_FLAGS(msg));
  1935. if (err)
  1936. goto out_freeiov;
  1937. if (MSG_CMSG_COMPAT & flags)
  1938. err = __put_user((unsigned long)msg_sys->msg_control - cmsg_ptr,
  1939. &msg_compat->msg_controllen);
  1940. else
  1941. err = __put_user((unsigned long)msg_sys->msg_control - cmsg_ptr,
  1942. &msg->msg_controllen);
  1943. if (err)
  1944. goto out_freeiov;
  1945. err = len;
  1946. out_freeiov:
  1947. if (iov != iovstack)
  1948. kfree(iov);
  1949. out:
  1950. return err;
  1951. }
  1952. /*
  1953. * BSD recvmsg interface
  1954. */
  1955. long __sys_recvmsg(int fd, struct msghdr __user *msg, unsigned flags)
  1956. {
  1957. int fput_needed, err;
  1958. struct msghdr msg_sys;
  1959. struct socket *sock;
  1960. sock = sockfd_lookup_light(fd, &err, &fput_needed);
  1961. if (!sock)
  1962. goto out;
  1963. err = ___sys_recvmsg(sock, msg, &msg_sys, flags, 0);
  1964. fput_light(sock->file, fput_needed);
  1965. out:
  1966. return err;
  1967. }
  1968. SYSCALL_DEFINE3(recvmsg, int, fd, struct msghdr __user *, msg,
  1969. unsigned int, flags)
  1970. {
  1971. if (flags & MSG_CMSG_COMPAT)
  1972. return -EINVAL;
  1973. return __sys_recvmsg(fd, msg, flags);
  1974. }
  1975. /*
  1976. * Linux recvmmsg interface
  1977. */
  1978. int __sys_recvmmsg(int fd, struct mmsghdr __user *mmsg, unsigned int vlen,
  1979. unsigned int flags, struct timespec *timeout)
  1980. {
  1981. int fput_needed, err, datagrams;
  1982. struct socket *sock;
  1983. struct mmsghdr __user *entry;
  1984. struct compat_mmsghdr __user *compat_entry;
  1985. struct msghdr msg_sys;
  1986. struct timespec end_time;
  1987. if (timeout &&
  1988. poll_select_set_timeout(&end_time, timeout->tv_sec,
  1989. timeout->tv_nsec))
  1990. return -EINVAL;
  1991. datagrams = 0;
  1992. sock = sockfd_lookup_light(fd, &err, &fput_needed);
  1993. if (!sock)
  1994. return err;
  1995. err = sock_error(sock->sk);
  1996. if (err)
  1997. goto out_put;
  1998. entry = mmsg;
  1999. compat_entry = (struct compat_mmsghdr __user *)mmsg;
  2000. while (datagrams < vlen) {
  2001. /*
  2002. * No need to ask LSM for more than the first datagram.
  2003. */
  2004. if (MSG_CMSG_COMPAT & flags) {
  2005. err = ___sys_recvmsg(sock, (struct msghdr __user *)compat_entry,
  2006. &msg_sys, flags & ~MSG_WAITFORONE,
  2007. datagrams);
  2008. if (err < 0)
  2009. break;
  2010. err = __put_user(err, &compat_entry->msg_len);
  2011. ++compat_entry;
  2012. } else {
  2013. err = ___sys_recvmsg(sock,
  2014. (struct msghdr __user *)entry,
  2015. &msg_sys, flags & ~MSG_WAITFORONE,
  2016. datagrams);
  2017. if (err < 0)
  2018. break;
  2019. err = put_user(err, &entry->msg_len);
  2020. ++entry;
  2021. }
  2022. if (err)
  2023. break;
  2024. ++datagrams;
  2025. /* MSG_WAITFORONE turns on MSG_DONTWAIT after one packet */
  2026. if (flags & MSG_WAITFORONE)
  2027. flags |= MSG_DONTWAIT;
  2028. if (timeout) {
  2029. ktime_get_ts(timeout);
  2030. *timeout = timespec_sub(end_time, *timeout);
  2031. if (timeout->tv_sec < 0) {
  2032. timeout->tv_sec = timeout->tv_nsec = 0;
  2033. break;
  2034. }
  2035. /* Timeout, return less than vlen datagrams */
  2036. if (timeout->tv_nsec == 0 && timeout->tv_sec == 0)
  2037. break;
  2038. }
  2039. /* Out of band data, return right away */
  2040. if (msg_sys.msg_flags & MSG_OOB)
  2041. break;
  2042. }
  2043. out_put:
  2044. fput_light(sock->file, fput_needed);
  2045. if (err == 0)
  2046. return datagrams;
  2047. if (datagrams != 0) {
  2048. /*
  2049. * We may return less entries than requested (vlen) if the
  2050. * sock is non block and there aren't enough datagrams...
  2051. */
  2052. if (err != -EAGAIN) {
  2053. /*
  2054. * ... or if recvmsg returns an error after we
  2055. * received some datagrams, where we record the
  2056. * error to return on the next call or if the
  2057. * app asks about it using getsockopt(SO_ERROR).
  2058. */
  2059. sock->sk->sk_err = -err;
  2060. }
  2061. return datagrams;
  2062. }
  2063. return err;
  2064. }
  2065. SYSCALL_DEFINE5(recvmmsg, int, fd, struct mmsghdr __user *, mmsg,
  2066. unsigned int, vlen, unsigned int, flags,
  2067. struct timespec __user *, timeout)
  2068. {
  2069. int datagrams;
  2070. struct timespec timeout_sys;
  2071. if (flags & MSG_CMSG_COMPAT)
  2072. return -EINVAL;
  2073. if (!timeout)
  2074. return __sys_recvmmsg(fd, mmsg, vlen, flags, NULL);
  2075. if (copy_from_user(&timeout_sys, timeout, sizeof(timeout_sys)))
  2076. return -EFAULT;
  2077. datagrams = __sys_recvmmsg(fd, mmsg, vlen, flags, &timeout_sys);
  2078. if (datagrams > 0 &&
  2079. copy_to_user(timeout, &timeout_sys, sizeof(timeout_sys)))
  2080. datagrams = -EFAULT;
  2081. return datagrams;
  2082. }
  2083. #ifdef __ARCH_WANT_SYS_SOCKETCALL
  2084. /* Argument list sizes for sys_socketcall */
  2085. #define AL(x) ((x) * sizeof(unsigned long))
  2086. static const unsigned char nargs[21] = {
  2087. AL(0), AL(3), AL(3), AL(3), AL(2), AL(3),
  2088. AL(3), AL(3), AL(4), AL(4), AL(4), AL(6),
  2089. AL(6), AL(2), AL(5), AL(5), AL(3), AL(3),
  2090. AL(4), AL(5), AL(4)
  2091. };
  2092. #undef AL
  2093. /*
  2094. * System call vectors.
  2095. *
  2096. * Argument checking cleaned up. Saved 20% in size.
  2097. * This function doesn't need to set the kernel lock because
  2098. * it is set by the callees.
  2099. */
  2100. SYSCALL_DEFINE2(socketcall, int, call, unsigned long __user *, args)
  2101. {
  2102. unsigned long a[AUDITSC_ARGS];
  2103. unsigned long a0, a1;
  2104. int err;
  2105. unsigned int len;
  2106. if (call < 1 || call > SYS_SENDMMSG)
  2107. return -EINVAL;
  2108. len = nargs[call];
  2109. if (len > sizeof(a))
  2110. return -EINVAL;
  2111. /* copy_from_user should be SMP safe. */
  2112. if (copy_from_user(a, args, len))
  2113. return -EFAULT;
  2114. err = audit_socketcall(nargs[call] / sizeof(unsigned long), a);
  2115. if (err)
  2116. return err;
  2117. a0 = a[0];
  2118. a1 = a[1];
  2119. switch (call) {
  2120. case SYS_SOCKET:
  2121. err = sys_socket(a0, a1, a[2]);
  2122. break;
  2123. case SYS_BIND:
  2124. err = sys_bind(a0, (struct sockaddr __user *)a1, a[2]);
  2125. break;
  2126. case SYS_CONNECT:
  2127. err = sys_connect(a0, (struct sockaddr __user *)a1, a[2]);
  2128. break;
  2129. case SYS_LISTEN:
  2130. err = sys_listen(a0, a1);
  2131. break;
  2132. case SYS_ACCEPT:
  2133. err = sys_accept4(a0, (struct sockaddr __user *)a1,
  2134. (int __user *)a[2], 0);
  2135. break;
  2136. case SYS_GETSOCKNAME:
  2137. err =
  2138. sys_getsockname(a0, (struct sockaddr __user *)a1,
  2139. (int __user *)a[2]);
  2140. break;
  2141. case SYS_GETPEERNAME:
  2142. err =
  2143. sys_getpeername(a0, (struct sockaddr __user *)a1,
  2144. (int __user *)a[2]);
  2145. break;
  2146. case SYS_SOCKETPAIR:
  2147. err = sys_socketpair(a0, a1, a[2], (int __user *)a[3]);
  2148. break;
  2149. case SYS_SEND:
  2150. err = sys_send(a0, (void __user *)a1, a[2], a[3]);
  2151. break;
  2152. case SYS_SENDTO:
  2153. err = sys_sendto(a0, (void __user *)a1, a[2], a[3],
  2154. (struct sockaddr __user *)a[4], a[5]);
  2155. break;
  2156. case SYS_RECV:
  2157. err = sys_recv(a0, (void __user *)a1, a[2], a[3]);
  2158. break;
  2159. case SYS_RECVFROM:
  2160. err = sys_recvfrom(a0, (void __user *)a1, a[2], a[3],
  2161. (struct sockaddr __user *)a[4],
  2162. (int __user *)a[5]);
  2163. break;
  2164. case SYS_SHUTDOWN:
  2165. err = sys_shutdown(a0, a1);
  2166. break;
  2167. case SYS_SETSOCKOPT:
  2168. err = sys_setsockopt(a0, a1, a[2], (char __user *)a[3], a[4]);
  2169. break;
  2170. case SYS_GETSOCKOPT:
  2171. err =
  2172. sys_getsockopt(a0, a1, a[2], (char __user *)a[3],
  2173. (int __user *)a[4]);
  2174. break;
  2175. case SYS_SENDMSG:
  2176. err = sys_sendmsg(a0, (struct msghdr __user *)a1, a[2]);
  2177. break;
  2178. case SYS_SENDMMSG:
  2179. err = sys_sendmmsg(a0, (struct mmsghdr __user *)a1, a[2], a[3]);
  2180. break;
  2181. case SYS_RECVMSG:
  2182. err = sys_recvmsg(a0, (struct msghdr __user *)a1, a[2]);
  2183. break;
  2184. case SYS_RECVMMSG:
  2185. err = sys_recvmmsg(a0, (struct mmsghdr __user *)a1, a[2], a[3],
  2186. (struct timespec __user *)a[4]);
  2187. break;
  2188. case SYS_ACCEPT4:
  2189. err = sys_accept4(a0, (struct sockaddr __user *)a1,
  2190. (int __user *)a[2], a[3]);
  2191. break;
  2192. default:
  2193. err = -EINVAL;
  2194. break;
  2195. }
  2196. return err;
  2197. }
  2198. #endif /* __ARCH_WANT_SYS_SOCKETCALL */
  2199. /**
  2200. * sock_register - add a socket protocol handler
  2201. * @ops: description of protocol
  2202. *
  2203. * This function is called by a protocol handler that wants to
  2204. * advertise its address family, and have it linked into the
  2205. * socket interface. The value ops->family coresponds to the
  2206. * socket system call protocol family.
  2207. */
  2208. int sock_register(const struct net_proto_family *ops)
  2209. {
  2210. int err;
  2211. if (ops->family >= NPROTO) {
  2212. printk(KERN_CRIT "protocol %d >= NPROTO(%d)\n", ops->family,
  2213. NPROTO);
  2214. return -ENOBUFS;
  2215. }
  2216. spin_lock(&net_family_lock);
  2217. if (rcu_dereference_protected(net_families[ops->family],
  2218. lockdep_is_held(&net_family_lock)))
  2219. err = -EEXIST;
  2220. else {
  2221. rcu_assign_pointer(net_families[ops->family], ops);
  2222. err = 0;
  2223. }
  2224. spin_unlock(&net_family_lock);
  2225. printk(KERN_INFO "NET: Registered protocol family %d\n", ops->family);
  2226. return err;
  2227. }
  2228. EXPORT_SYMBOL(sock_register);
  2229. /**
  2230. * sock_unregister - remove a protocol handler
  2231. * @family: protocol family to remove
  2232. *
  2233. * This function is called by a protocol handler that wants to
  2234. * remove its address family, and have it unlinked from the
  2235. * new socket creation.
  2236. *
  2237. * If protocol handler is a module, then it can use module reference
  2238. * counts to protect against new references. If protocol handler is not
  2239. * a module then it needs to provide its own protection in
  2240. * the ops->create routine.
  2241. */
  2242. void sock_unregister(int family)
  2243. {
  2244. BUG_ON(family < 0 || family >= NPROTO);
  2245. spin_lock(&net_family_lock);
  2246. RCU_INIT_POINTER(net_families[family], NULL);
  2247. spin_unlock(&net_family_lock);
  2248. synchronize_rcu();
  2249. printk(KERN_INFO "NET: Unregistered protocol family %d\n", family);
  2250. }
  2251. EXPORT_SYMBOL(sock_unregister);
  2252. static int __init sock_init(void)
  2253. {
  2254. int err;
  2255. /*
  2256. * Initialize the network sysctl infrastructure.
  2257. */
  2258. err = net_sysctl_init();
  2259. if (err)
  2260. goto out;
  2261. /*
  2262. * Initialize skbuff SLAB cache
  2263. */
  2264. skb_init();
  2265. /*
  2266. * Initialize the protocols module.
  2267. */
  2268. init_inodecache();
  2269. err = register_filesystem(&sock_fs_type);
  2270. if (err)
  2271. goto out_fs;
  2272. sock_mnt = kern_mount(&sock_fs_type);
  2273. if (IS_ERR(sock_mnt)) {
  2274. err = PTR_ERR(sock_mnt);
  2275. goto out_mount;
  2276. }
  2277. /* The real protocol initialization is performed in later initcalls.
  2278. */
  2279. #ifdef CONFIG_NETFILTER
  2280. err = netfilter_init();
  2281. if (err)
  2282. goto out;
  2283. #endif
  2284. #ifdef CONFIG_NETWORK_PHY_TIMESTAMPING
  2285. skb_timestamping_init();
  2286. #endif
  2287. out:
  2288. return err;
  2289. out_mount:
  2290. unregister_filesystem(&sock_fs_type);
  2291. out_fs:
  2292. goto out;
  2293. }
  2294. core_initcall(sock_init); /* early initcall */
  2295. #ifdef CONFIG_PROC_FS
  2296. void socket_seq_show(struct seq_file *seq)
  2297. {
  2298. int cpu;
  2299. int counter = 0;
  2300. for_each_possible_cpu(cpu)
  2301. counter += per_cpu(sockets_in_use, cpu);
  2302. /* It can be negative, by the way. 8) */
  2303. if (counter < 0)
  2304. counter = 0;
  2305. seq_printf(seq, "sockets: used %d\n", counter);
  2306. }
  2307. #endif /* CONFIG_PROC_FS */
  2308. #ifdef CONFIG_COMPAT
  2309. static int do_siocgstamp(struct net *net, struct socket *sock,
  2310. unsigned int cmd, void __user *up)
  2311. {
  2312. mm_segment_t old_fs = get_fs();
  2313. struct timeval ktv;
  2314. int err;
  2315. set_fs(KERNEL_DS);
  2316. err = sock_do_ioctl(net, sock, cmd, (unsigned long)&ktv);
  2317. set_fs(old_fs);
  2318. if (!err)
  2319. err = compat_put_timeval(&ktv, up);
  2320. return err;
  2321. }
  2322. static int do_siocgstampns(struct net *net, struct socket *sock,
  2323. unsigned int cmd, void __user *up)
  2324. {
  2325. mm_segment_t old_fs = get_fs();
  2326. struct timespec kts;
  2327. int err;
  2328. set_fs(KERNEL_DS);
  2329. err = sock_do_ioctl(net, sock, cmd, (unsigned long)&kts);
  2330. set_fs(old_fs);
  2331. if (!err)
  2332. err = compat_put_timespec(&kts, up);
  2333. return err;
  2334. }
  2335. static int dev_ifname32(struct net *net, struct compat_ifreq __user *uifr32)
  2336. {
  2337. struct ifreq __user *uifr;
  2338. int err;
  2339. uifr = compat_alloc_user_space(sizeof(struct ifreq));
  2340. if (copy_in_user(uifr, uifr32, sizeof(struct compat_ifreq)))
  2341. return -EFAULT;
  2342. err = dev_ioctl(net, SIOCGIFNAME, uifr);
  2343. if (err)
  2344. return err;
  2345. if (copy_in_user(uifr32, uifr, sizeof(struct compat_ifreq)))
  2346. return -EFAULT;
  2347. return 0;
  2348. }
  2349. static int dev_ifconf(struct net *net, struct compat_ifconf __user *uifc32)
  2350. {
  2351. struct compat_ifconf ifc32;
  2352. struct ifconf ifc;
  2353. struct ifconf __user *uifc;
  2354. struct compat_ifreq __user *ifr32;
  2355. struct ifreq __user *ifr;
  2356. unsigned int i, j;
  2357. int err;
  2358. if (copy_from_user(&ifc32, uifc32, sizeof(struct compat_ifconf)))
  2359. return -EFAULT;
  2360. memset(&ifc, 0, sizeof(ifc));
  2361. if (ifc32.ifcbuf == 0) {
  2362. ifc32.ifc_len = 0;
  2363. ifc.ifc_len = 0;
  2364. ifc.ifc_req = NULL;
  2365. uifc = compat_alloc_user_space(sizeof(struct ifconf));
  2366. } else {
  2367. size_t len = ((ifc32.ifc_len / sizeof(struct compat_ifreq)) + 1) *
  2368. sizeof(struct ifreq);
  2369. uifc = compat_alloc_user_space(sizeof(struct ifconf) + len);
  2370. ifc.ifc_len = len;
  2371. ifr = ifc.ifc_req = (void __user *)(uifc + 1);
  2372. ifr32 = compat_ptr(ifc32.ifcbuf);
  2373. for (i = 0; i < ifc32.ifc_len; i += sizeof(struct compat_ifreq)) {
  2374. if (copy_in_user(ifr, ifr32, sizeof(struct compat_ifreq)))
  2375. return -EFAULT;
  2376. ifr++;
  2377. ifr32++;
  2378. }
  2379. }
  2380. if (copy_to_user(uifc, &ifc, sizeof(struct ifconf)))
  2381. return -EFAULT;
  2382. err = dev_ioctl(net, SIOCGIFCONF, uifc);
  2383. if (err)
  2384. return err;
  2385. if (copy_from_user(&ifc, uifc, sizeof(struct ifconf)))
  2386. return -EFAULT;
  2387. ifr = ifc.ifc_req;
  2388. ifr32 = compat_ptr(ifc32.ifcbuf);
  2389. for (i = 0, j = 0;
  2390. i + sizeof(struct compat_ifreq) <= ifc32.ifc_len && j < ifc.ifc_len;
  2391. i += sizeof(struct compat_ifreq), j += sizeof(struct ifreq)) {
  2392. if (copy_in_user(ifr32, ifr, sizeof(struct compat_ifreq)))
  2393. return -EFAULT;
  2394. ifr32++;
  2395. ifr++;
  2396. }
  2397. if (ifc32.ifcbuf == 0) {
  2398. /* Translate from 64-bit structure multiple to
  2399. * a 32-bit one.
  2400. */
  2401. i = ifc.ifc_len;
  2402. i = ((i / sizeof(struct ifreq)) * sizeof(struct compat_ifreq));
  2403. ifc32.ifc_len = i;
  2404. } else {
  2405. ifc32.ifc_len = i;
  2406. }
  2407. if (copy_to_user(uifc32, &ifc32, sizeof(struct compat_ifconf)))
  2408. return -EFAULT;
  2409. return 0;
  2410. }
  2411. static int ethtool_ioctl(struct net *net, struct compat_ifreq __user *ifr32)
  2412. {
  2413. struct compat_ethtool_rxnfc __user *compat_rxnfc;
  2414. bool convert_in = false, convert_out = false;
  2415. size_t buf_size = ALIGN(sizeof(struct ifreq), 8);
  2416. struct ethtool_rxnfc __user *rxnfc;
  2417. struct ifreq __user *ifr;
  2418. u32 rule_cnt = 0, actual_rule_cnt;
  2419. u32 ethcmd;
  2420. u32 data;
  2421. int ret;
  2422. if (get_user(data, &ifr32->ifr_ifru.ifru_data))
  2423. return -EFAULT;
  2424. compat_rxnfc = compat_ptr(data);
  2425. if (get_user(ethcmd, &compat_rxnfc->cmd))
  2426. return -EFAULT;
  2427. /* Most ethtool structures are defined without padding.
  2428. * Unfortunately struct ethtool_rxnfc is an exception.
  2429. */
  2430. switch (ethcmd) {
  2431. default:
  2432. break;
  2433. case ETHTOOL_GRXCLSRLALL:
  2434. /* Buffer size is variable */
  2435. if (get_user(rule_cnt, &compat_rxnfc->rule_cnt))
  2436. return -EFAULT;
  2437. if (rule_cnt > KMALLOC_MAX_SIZE / sizeof(u32))
  2438. return -ENOMEM;
  2439. buf_size += rule_cnt * sizeof(u32);
  2440. /* fall through */
  2441. case ETHTOOL_GRXRINGS:
  2442. case ETHTOOL_GRXCLSRLCNT:
  2443. case ETHTOOL_GRXCLSRULE:
  2444. case ETHTOOL_SRXCLSRLINS:
  2445. convert_out = true;
  2446. /* fall through */
  2447. case ETHTOOL_SRXCLSRLDEL:
  2448. buf_size += sizeof(struct ethtool_rxnfc);
  2449. convert_in = true;
  2450. break;
  2451. }
  2452. ifr = compat_alloc_user_space(buf_size);
  2453. rxnfc = (void __user *)ifr + ALIGN(sizeof(struct ifreq), 8);
  2454. if (copy_in_user(&ifr->ifr_name, &ifr32->ifr_name, IFNAMSIZ))
  2455. return -EFAULT;
  2456. if (put_user(convert_in ? rxnfc : compat_ptr(data),
  2457. &ifr->ifr_ifru.ifru_data))
  2458. return -EFAULT;
  2459. if (convert_in) {
  2460. /* We expect there to be holes between fs.m_ext and
  2461. * fs.ring_cookie and at the end of fs, but nowhere else.
  2462. */
  2463. BUILD_BUG_ON(offsetof(struct compat_ethtool_rxnfc, fs.m_ext) +
  2464. sizeof(compat_rxnfc->fs.m_ext) !=
  2465. offsetof(struct ethtool_rxnfc, fs.m_ext) +
  2466. sizeof(rxnfc->fs.m_ext));
  2467. BUILD_BUG_ON(
  2468. offsetof(struct compat_ethtool_rxnfc, fs.location) -
  2469. offsetof(struct compat_ethtool_rxnfc, fs.ring_cookie) !=
  2470. offsetof(struct ethtool_rxnfc, fs.location) -
  2471. offsetof(struct ethtool_rxnfc, fs.ring_cookie));
  2472. if (copy_in_user(rxnfc, compat_rxnfc,
  2473. (void __user *)(&rxnfc->fs.m_ext + 1) -
  2474. (void __user *)rxnfc) ||
  2475. copy_in_user(&rxnfc->fs.ring_cookie,
  2476. &compat_rxnfc->fs.ring_cookie,
  2477. (void __user *)(&rxnfc->fs.location + 1) -
  2478. (void __user *)&rxnfc->fs.ring_cookie) ||
  2479. copy_in_user(&rxnfc->rule_cnt, &compat_rxnfc->rule_cnt,
  2480. sizeof(rxnfc->rule_cnt)))
  2481. return -EFAULT;
  2482. }
  2483. ret = dev_ioctl(net, SIOCETHTOOL, ifr);
  2484. if (ret)
  2485. return ret;
  2486. if (convert_out) {
  2487. if (copy_in_user(compat_rxnfc, rxnfc,
  2488. (const void __user *)(&rxnfc->fs.m_ext + 1) -
  2489. (const void __user *)rxnfc) ||
  2490. copy_in_user(&compat_rxnfc->fs.ring_cookie,
  2491. &rxnfc->fs.ring_cookie,
  2492. (const void __user *)(&rxnfc->fs.location + 1) -
  2493. (const void __user *)&rxnfc->fs.ring_cookie) ||
  2494. copy_in_user(&compat_rxnfc->rule_cnt, &rxnfc->rule_cnt,
  2495. sizeof(rxnfc->rule_cnt)))
  2496. return -EFAULT;
  2497. if (ethcmd == ETHTOOL_GRXCLSRLALL) {
  2498. /* As an optimisation, we only copy the actual
  2499. * number of rules that the underlying
  2500. * function returned. Since Mallory might
  2501. * change the rule count in user memory, we
  2502. * check that it is less than the rule count
  2503. * originally given (as the user buffer size),
  2504. * which has been range-checked.
  2505. */
  2506. if (get_user(actual_rule_cnt, &rxnfc->rule_cnt))
  2507. return -EFAULT;
  2508. if (actual_rule_cnt < rule_cnt)
  2509. rule_cnt = actual_rule_cnt;
  2510. if (copy_in_user(&compat_rxnfc->rule_locs[0],
  2511. &rxnfc->rule_locs[0],
  2512. rule_cnt * sizeof(u32)))
  2513. return -EFAULT;
  2514. }
  2515. }
  2516. return 0;
  2517. }
  2518. static int compat_siocwandev(struct net *net, struct compat_ifreq __user *uifr32)
  2519. {
  2520. void __user *uptr;
  2521. compat_uptr_t uptr32;
  2522. struct ifreq __user *uifr;
  2523. uifr = compat_alloc_user_space(sizeof(*uifr));
  2524. if (copy_in_user(uifr, uifr32, sizeof(struct compat_ifreq)))
  2525. return -EFAULT;
  2526. if (get_user(uptr32, &uifr32->ifr_settings.ifs_ifsu))
  2527. return -EFAULT;
  2528. uptr = compat_ptr(uptr32);
  2529. if (put_user(uptr, &uifr->ifr_settings.ifs_ifsu.raw_hdlc))
  2530. return -EFAULT;
  2531. return dev_ioctl(net, SIOCWANDEV, uifr);
  2532. }
  2533. static int bond_ioctl(struct net *net, unsigned int cmd,
  2534. struct compat_ifreq __user *ifr32)
  2535. {
  2536. struct ifreq kifr;
  2537. struct ifreq __user *uifr;
  2538. mm_segment_t old_fs;
  2539. int err;
  2540. u32 data;
  2541. void __user *datap;
  2542. switch (cmd) {
  2543. case SIOCBONDENSLAVE:
  2544. case SIOCBONDRELEASE:
  2545. case SIOCBONDSETHWADDR:
  2546. case SIOCBONDCHANGEACTIVE:
  2547. if (copy_from_user(&kifr, ifr32, sizeof(struct compat_ifreq)))
  2548. return -EFAULT;
  2549. old_fs = get_fs();
  2550. set_fs(KERNEL_DS);
  2551. err = dev_ioctl(net, cmd,
  2552. (struct ifreq __user __force *) &kifr);
  2553. set_fs(old_fs);
  2554. return err;
  2555. case SIOCBONDSLAVEINFOQUERY:
  2556. case SIOCBONDINFOQUERY:
  2557. uifr = compat_alloc_user_space(sizeof(*uifr));
  2558. if (copy_in_user(&uifr->ifr_name, &ifr32->ifr_name, IFNAMSIZ))
  2559. return -EFAULT;
  2560. if (get_user(data, &ifr32->ifr_ifru.ifru_data))
  2561. return -EFAULT;
  2562. datap = compat_ptr(data);
  2563. if (put_user(datap, &uifr->ifr_ifru.ifru_data))
  2564. return -EFAULT;
  2565. return dev_ioctl(net, cmd, uifr);
  2566. default:
  2567. return -ENOIOCTLCMD;
  2568. }
  2569. }
  2570. static int siocdevprivate_ioctl(struct net *net, unsigned int cmd,
  2571. struct compat_ifreq __user *u_ifreq32)
  2572. {
  2573. struct ifreq __user *u_ifreq64;
  2574. char tmp_buf[IFNAMSIZ];
  2575. void __user *data64;
  2576. u32 data32;
  2577. if (copy_from_user(&tmp_buf[0], &(u_ifreq32->ifr_ifrn.ifrn_name[0]),
  2578. IFNAMSIZ))
  2579. return -EFAULT;
  2580. if (__get_user(data32, &u_ifreq32->ifr_ifru.ifru_data))
  2581. return -EFAULT;
  2582. data64 = compat_ptr(data32);
  2583. u_ifreq64 = compat_alloc_user_space(sizeof(*u_ifreq64));
  2584. /* Don't check these user accesses, just let that get trapped
  2585. * in the ioctl handler instead.
  2586. */
  2587. if (copy_to_user(&u_ifreq64->ifr_ifrn.ifrn_name[0], &tmp_buf[0],
  2588. IFNAMSIZ))
  2589. return -EFAULT;
  2590. if (__put_user(data64, &u_ifreq64->ifr_ifru.ifru_data))
  2591. return -EFAULT;
  2592. return dev_ioctl(net, cmd, u_ifreq64);
  2593. }
  2594. static int dev_ifsioc(struct net *net, struct socket *sock,
  2595. unsigned int cmd, struct compat_ifreq __user *uifr32)
  2596. {
  2597. struct ifreq __user *uifr;
  2598. int err;
  2599. uifr = compat_alloc_user_space(sizeof(*uifr));
  2600. if (copy_in_user(uifr, uifr32, sizeof(*uifr32)))
  2601. return -EFAULT;
  2602. err = sock_do_ioctl(net, sock, cmd, (unsigned long)uifr);
  2603. if (!err) {
  2604. switch (cmd) {
  2605. case SIOCGIFFLAGS:
  2606. case SIOCGIFMETRIC:
  2607. case SIOCGIFMTU:
  2608. case SIOCGIFMEM:
  2609. case SIOCGIFHWADDR:
  2610. case SIOCGIFINDEX:
  2611. case SIOCGIFADDR:
  2612. case SIOCGIFBRDADDR:
  2613. case SIOCGIFDSTADDR:
  2614. case SIOCGIFNETMASK:
  2615. case SIOCGIFPFLAGS:
  2616. case SIOCGIFTXQLEN:
  2617. case SIOCGMIIPHY:
  2618. case SIOCGMIIREG:
  2619. if (copy_in_user(uifr32, uifr, sizeof(*uifr32)))
  2620. err = -EFAULT;
  2621. break;
  2622. }
  2623. }
  2624. return err;
  2625. }
  2626. static int compat_sioc_ifmap(struct net *net, unsigned int cmd,
  2627. struct compat_ifreq __user *uifr32)
  2628. {
  2629. struct ifreq ifr;
  2630. struct compat_ifmap __user *uifmap32;
  2631. mm_segment_t old_fs;
  2632. int err;
  2633. uifmap32 = &uifr32->ifr_ifru.ifru_map;
  2634. err = copy_from_user(&ifr, uifr32, sizeof(ifr.ifr_name));
  2635. err |= get_user(ifr.ifr_map.mem_start, &uifmap32->mem_start);
  2636. err |= get_user(ifr.ifr_map.mem_end, &uifmap32->mem_end);
  2637. err |= get_user(ifr.ifr_map.base_addr, &uifmap32->base_addr);
  2638. err |= get_user(ifr.ifr_map.irq, &uifmap32->irq);
  2639. err |= get_user(ifr.ifr_map.dma, &uifmap32->dma);
  2640. err |= get_user(ifr.ifr_map.port, &uifmap32->port);
  2641. if (err)
  2642. return -EFAULT;
  2643. old_fs = get_fs();
  2644. set_fs(KERNEL_DS);
  2645. err = dev_ioctl(net, cmd, (void __user __force *)&ifr);
  2646. set_fs(old_fs);
  2647. if (cmd == SIOCGIFMAP && !err) {
  2648. err = copy_to_user(uifr32, &ifr, sizeof(ifr.ifr_name));
  2649. err |= put_user(ifr.ifr_map.mem_start, &uifmap32->mem_start);
  2650. err |= put_user(ifr.ifr_map.mem_end, &uifmap32->mem_end);
  2651. err |= put_user(ifr.ifr_map.base_addr, &uifmap32->base_addr);
  2652. err |= put_user(ifr.ifr_map.irq, &uifmap32->irq);
  2653. err |= put_user(ifr.ifr_map.dma, &uifmap32->dma);
  2654. err |= put_user(ifr.ifr_map.port, &uifmap32->port);
  2655. if (err)
  2656. err = -EFAULT;
  2657. }
  2658. return err;
  2659. }
  2660. static int compat_siocshwtstamp(struct net *net, struct compat_ifreq __user *uifr32)
  2661. {
  2662. void __user *uptr;
  2663. compat_uptr_t uptr32;
  2664. struct ifreq __user *uifr;
  2665. uifr = compat_alloc_user_space(sizeof(*uifr));
  2666. if (copy_in_user(uifr, uifr32, sizeof(struct compat_ifreq)))
  2667. return -EFAULT;
  2668. if (get_user(uptr32, &uifr32->ifr_data))
  2669. return -EFAULT;
  2670. uptr = compat_ptr(uptr32);
  2671. if (put_user(uptr, &uifr->ifr_data))
  2672. return -EFAULT;
  2673. return dev_ioctl(net, SIOCSHWTSTAMP, uifr);
  2674. }
  2675. struct rtentry32 {
  2676. u32 rt_pad1;
  2677. struct sockaddr rt_dst; /* target address */
  2678. struct sockaddr rt_gateway; /* gateway addr (RTF_GATEWAY) */
  2679. struct sockaddr rt_genmask; /* target network mask (IP) */
  2680. unsigned short rt_flags;
  2681. short rt_pad2;
  2682. u32 rt_pad3;
  2683. unsigned char rt_tos;
  2684. unsigned char rt_class;
  2685. short rt_pad4;
  2686. short rt_metric; /* +1 for binary compatibility! */
  2687. /* char * */ u32 rt_dev; /* forcing the device at add */
  2688. u32 rt_mtu; /* per route MTU/Window */
  2689. u32 rt_window; /* Window clamping */
  2690. unsigned short rt_irtt; /* Initial RTT */
  2691. };
  2692. struct in6_rtmsg32 {
  2693. struct in6_addr rtmsg_dst;
  2694. struct in6_addr rtmsg_src;
  2695. struct in6_addr rtmsg_gateway;
  2696. u32 rtmsg_type;
  2697. u16 rtmsg_dst_len;
  2698. u16 rtmsg_src_len;
  2699. u32 rtmsg_metric;
  2700. u32 rtmsg_info;
  2701. u32 rtmsg_flags;
  2702. s32 rtmsg_ifindex;
  2703. };
  2704. static int routing_ioctl(struct net *net, struct socket *sock,
  2705. unsigned int cmd, void __user *argp)
  2706. {
  2707. int ret;
  2708. void *r = NULL;
  2709. struct in6_rtmsg r6;
  2710. struct rtentry r4;
  2711. char devname[16];
  2712. u32 rtdev;
  2713. mm_segment_t old_fs = get_fs();
  2714. if (sock && sock->sk && sock->sk->sk_family == AF_INET6) { /* ipv6 */
  2715. struct in6_rtmsg32 __user *ur6 = argp;
  2716. ret = copy_from_user(&r6.rtmsg_dst, &(ur6->rtmsg_dst),
  2717. 3 * sizeof(struct in6_addr));
  2718. ret |= get_user(r6.rtmsg_type, &(ur6->rtmsg_type));
  2719. ret |= get_user(r6.rtmsg_dst_len, &(ur6->rtmsg_dst_len));
  2720. ret |= get_user(r6.rtmsg_src_len, &(ur6->rtmsg_src_len));
  2721. ret |= get_user(r6.rtmsg_metric, &(ur6->rtmsg_metric));
  2722. ret |= get_user(r6.rtmsg_info, &(ur6->rtmsg_info));
  2723. ret |= get_user(r6.rtmsg_flags, &(ur6->rtmsg_flags));
  2724. ret |= get_user(r6.rtmsg_ifindex, &(ur6->rtmsg_ifindex));
  2725. r = (void *) &r6;
  2726. } else { /* ipv4 */
  2727. struct rtentry32 __user *ur4 = argp;
  2728. ret = copy_from_user(&r4.rt_dst, &(ur4->rt_dst),
  2729. 3 * sizeof(struct sockaddr));
  2730. ret |= get_user(r4.rt_flags, &(ur4->rt_flags));
  2731. ret |= get_user(r4.rt_metric, &(ur4->rt_metric));
  2732. ret |= get_user(r4.rt_mtu, &(ur4->rt_mtu));
  2733. ret |= get_user(r4.rt_window, &(ur4->rt_window));
  2734. ret |= get_user(r4.rt_irtt, &(ur4->rt_irtt));
  2735. ret |= get_user(rtdev, &(ur4->rt_dev));
  2736. if (rtdev) {
  2737. ret |= copy_from_user(devname, compat_ptr(rtdev), 15);
  2738. r4.rt_dev = (char __user __force *)devname;
  2739. devname[15] = 0;
  2740. } else
  2741. r4.rt_dev = NULL;
  2742. r = (void *) &r4;
  2743. }
  2744. if (ret) {
  2745. ret = -EFAULT;
  2746. goto out;
  2747. }
  2748. set_fs(KERNEL_DS);
  2749. ret = sock_do_ioctl(net, sock, cmd, (unsigned long) r);
  2750. set_fs(old_fs);
  2751. out:
  2752. return ret;
  2753. }
  2754. /* Since old style bridge ioctl's endup using SIOCDEVPRIVATE
  2755. * for some operations; this forces use of the newer bridge-utils that
  2756. * use compatible ioctls
  2757. */
  2758. static int old_bridge_ioctl(compat_ulong_t __user *argp)
  2759. {
  2760. compat_ulong_t tmp;
  2761. if (get_user(tmp, argp))
  2762. return -EFAULT;
  2763. if (tmp == BRCTL_GET_VERSION)
  2764. return BRCTL_VERSION + 1;
  2765. return -EINVAL;
  2766. }
  2767. static int compat_sock_ioctl_trans(struct file *file, struct socket *sock,
  2768. unsigned int cmd, unsigned long arg)
  2769. {
  2770. void __user *argp = compat_ptr(arg);
  2771. struct sock *sk = sock->sk;
  2772. struct net *net = sock_net(sk);
  2773. if (cmd >= SIOCDEVPRIVATE && cmd <= (SIOCDEVPRIVATE + 15))
  2774. return siocdevprivate_ioctl(net, cmd, argp);
  2775. switch (cmd) {
  2776. case SIOCSIFBR:
  2777. case SIOCGIFBR:
  2778. return old_bridge_ioctl(argp);
  2779. case SIOCGIFNAME:
  2780. return dev_ifname32(net, argp);
  2781. case SIOCGIFCONF:
  2782. return dev_ifconf(net, argp);
  2783. case SIOCETHTOOL:
  2784. return ethtool_ioctl(net, argp);
  2785. case SIOCWANDEV:
  2786. return compat_siocwandev(net, argp);
  2787. case SIOCGIFMAP:
  2788. case SIOCSIFMAP:
  2789. return compat_sioc_ifmap(net, cmd, argp);
  2790. case SIOCBONDENSLAVE:
  2791. case SIOCBONDRELEASE:
  2792. case SIOCBONDSETHWADDR:
  2793. case SIOCBONDSLAVEINFOQUERY:
  2794. case SIOCBONDINFOQUERY:
  2795. case SIOCBONDCHANGEACTIVE:
  2796. return bond_ioctl(net, cmd, argp);
  2797. case SIOCADDRT:
  2798. case SIOCDELRT:
  2799. return routing_ioctl(net, sock, cmd, argp);
  2800. case SIOCGSTAMP:
  2801. return do_siocgstamp(net, sock, cmd, argp);
  2802. case SIOCGSTAMPNS:
  2803. return do_siocgstampns(net, sock, cmd, argp);
  2804. case SIOCSHWTSTAMP:
  2805. return compat_siocshwtstamp(net, argp);
  2806. case FIOSETOWN:
  2807. case SIOCSPGRP:
  2808. case FIOGETOWN:
  2809. case SIOCGPGRP:
  2810. case SIOCBRADDBR:
  2811. case SIOCBRDELBR:
  2812. case SIOCGIFVLAN:
  2813. case SIOCSIFVLAN:
  2814. case SIOCADDDLCI:
  2815. case SIOCDELDLCI:
  2816. return sock_ioctl(file, cmd, arg);
  2817. case SIOCGIFFLAGS:
  2818. case SIOCSIFFLAGS:
  2819. case SIOCGIFMETRIC:
  2820. case SIOCSIFMETRIC:
  2821. case SIOCGIFMTU:
  2822. case SIOCSIFMTU:
  2823. case SIOCGIFMEM:
  2824. case SIOCSIFMEM:
  2825. case SIOCGIFHWADDR:
  2826. case SIOCSIFHWADDR:
  2827. case SIOCADDMULTI:
  2828. case SIOCDELMULTI:
  2829. case SIOCGIFINDEX:
  2830. case SIOCGIFADDR:
  2831. case SIOCSIFADDR:
  2832. case SIOCSIFHWBROADCAST:
  2833. case SIOCDIFADDR:
  2834. case SIOCGIFBRDADDR:
  2835. case SIOCSIFBRDADDR:
  2836. case SIOCGIFDSTADDR:
  2837. case SIOCSIFDSTADDR:
  2838. case SIOCGIFNETMASK:
  2839. case SIOCSIFNETMASK:
  2840. case SIOCSIFPFLAGS:
  2841. case SIOCGIFPFLAGS:
  2842. case SIOCGIFTXQLEN:
  2843. case SIOCSIFTXQLEN:
  2844. case SIOCBRADDIF:
  2845. case SIOCBRDELIF:
  2846. case SIOCSIFNAME:
  2847. case SIOCGMIIPHY:
  2848. case SIOCGMIIREG:
  2849. case SIOCSMIIREG:
  2850. return dev_ifsioc(net, sock, cmd, argp);
  2851. case SIOCSARP:
  2852. case SIOCGARP:
  2853. case SIOCDARP:
  2854. case SIOCATMARK:
  2855. return sock_do_ioctl(net, sock, cmd, arg);
  2856. }
  2857. return -ENOIOCTLCMD;
  2858. }
  2859. static long compat_sock_ioctl(struct file *file, unsigned int cmd,
  2860. unsigned long arg)
  2861. {
  2862. struct socket *sock = file->private_data;
  2863. int ret = -ENOIOCTLCMD;
  2864. struct sock *sk;
  2865. struct net *net;
  2866. sk = sock->sk;
  2867. net = sock_net(sk);
  2868. if (sock->ops->compat_ioctl)
  2869. ret = sock->ops->compat_ioctl(sock, cmd, arg);
  2870. if (ret == -ENOIOCTLCMD &&
  2871. (cmd >= SIOCIWFIRST && cmd <= SIOCIWLAST))
  2872. ret = compat_wext_handle_ioctl(net, cmd, arg);
  2873. if (ret == -ENOIOCTLCMD)
  2874. ret = compat_sock_ioctl_trans(file, sock, cmd, arg);
  2875. return ret;
  2876. }
  2877. #endif
  2878. int kernel_bind(struct socket *sock, struct sockaddr *addr, int addrlen)
  2879. {
  2880. return sock->ops->bind(sock, addr, addrlen);
  2881. }
  2882. EXPORT_SYMBOL(kernel_bind);
  2883. int kernel_listen(struct socket *sock, int backlog)
  2884. {
  2885. return sock->ops->listen(sock, backlog);
  2886. }
  2887. EXPORT_SYMBOL(kernel_listen);
  2888. int kernel_accept(struct socket *sock, struct socket **newsock, int flags)
  2889. {
  2890. struct sock *sk = sock->sk;
  2891. int err;
  2892. err = sock_create_lite(sk->sk_family, sk->sk_type, sk->sk_protocol,
  2893. newsock);
  2894. if (err < 0)
  2895. goto done;
  2896. err = sock->ops->accept(sock, *newsock, flags);
  2897. if (err < 0) {
  2898. sock_release(*newsock);
  2899. *newsock = NULL;
  2900. goto done;
  2901. }
  2902. (*newsock)->ops = sock->ops;
  2903. __module_get((*newsock)->ops->owner);
  2904. done:
  2905. return err;
  2906. }
  2907. EXPORT_SYMBOL(kernel_accept);
  2908. int kernel_connect(struct socket *sock, struct sockaddr *addr, int addrlen,
  2909. int flags)
  2910. {
  2911. return sock->ops->connect(sock, addr, addrlen, flags);
  2912. }
  2913. EXPORT_SYMBOL(kernel_connect);
  2914. int kernel_getsockname(struct socket *sock, struct sockaddr *addr,
  2915. int *addrlen)
  2916. {
  2917. return sock->ops->getname(sock, addr, addrlen, 0);
  2918. }
  2919. EXPORT_SYMBOL(kernel_getsockname);
  2920. int kernel_getpeername(struct socket *sock, struct sockaddr *addr,
  2921. int *addrlen)
  2922. {
  2923. return sock->ops->getname(sock, addr, addrlen, 1);
  2924. }
  2925. EXPORT_SYMBOL(kernel_getpeername);
  2926. int kernel_getsockopt(struct socket *sock, int level, int optname,
  2927. char *optval, int *optlen)
  2928. {
  2929. mm_segment_t oldfs = get_fs();
  2930. char __user *uoptval;
  2931. int __user *uoptlen;
  2932. int err;
  2933. uoptval = (char __user __force *) optval;
  2934. uoptlen = (int __user __force *) optlen;
  2935. set_fs(KERNEL_DS);
  2936. if (level == SOL_SOCKET)
  2937. err = sock_getsockopt(sock, level, optname, uoptval, uoptlen);
  2938. else
  2939. err = sock->ops->getsockopt(sock, level, optname, uoptval,
  2940. uoptlen);
  2941. set_fs(oldfs);
  2942. return err;
  2943. }
  2944. EXPORT_SYMBOL(kernel_getsockopt);
  2945. int kernel_setsockopt(struct socket *sock, int level, int optname,
  2946. char *optval, unsigned int optlen)
  2947. {
  2948. mm_segment_t oldfs = get_fs();
  2949. char __user *uoptval;
  2950. int err;
  2951. uoptval = (char __user __force *) optval;
  2952. set_fs(KERNEL_DS);
  2953. if (level == SOL_SOCKET)
  2954. err = sock_setsockopt(sock, level, optname, uoptval, optlen);
  2955. else
  2956. err = sock->ops->setsockopt(sock, level, optname, uoptval,
  2957. optlen);
  2958. set_fs(oldfs);
  2959. return err;
  2960. }
  2961. EXPORT_SYMBOL(kernel_setsockopt);
  2962. int kernel_sendpage(struct socket *sock, struct page *page, int offset,
  2963. size_t size, int flags)
  2964. {
  2965. if (sock->ops->sendpage)
  2966. return sock->ops->sendpage(sock, page, offset, size, flags);
  2967. return sock_no_sendpage(sock, page, offset, size, flags);
  2968. }
  2969. EXPORT_SYMBOL(kernel_sendpage);
  2970. int kernel_sock_ioctl(struct socket *sock, int cmd, unsigned long arg)
  2971. {
  2972. mm_segment_t oldfs = get_fs();
  2973. int err;
  2974. set_fs(KERNEL_DS);
  2975. err = sock->ops->ioctl(sock, cmd, arg);
  2976. set_fs(oldfs);
  2977. return err;
  2978. }
  2979. EXPORT_SYMBOL(kernel_sock_ioctl);
  2980. int kernel_sock_shutdown(struct socket *sock, enum sock_shutdown_cmd how)
  2981. {
  2982. return sock->ops->shutdown(sock, how);
  2983. }
  2984. EXPORT_SYMBOL(kernel_sock_shutdown);