home *** CD-ROM | disk | FTP | other *** search
/ sustworks.com / 2014.06.sustworks.com.tar / sustworks.com / open_source_IPNetSentry_TNKE.dmg / IPNetSentry_TNKE.c < prev    next >
C/C++ Source or Header  |  2005-08-22  |  59KB  |  1,951 lines
  1. //
  2. //  IPNetSentry_TNKE.c
  3. //  Mac OS X Interface Filter NKE
  4. //
  5. //  Created by psichel [PAS] on Teus Nov 12 2002.
  6. //  Based on SharedIP and TCPLogger provided as Open Source sample code
  7. //    from Apple Computer.
  8. //
  9. //    See IPNetSentry_TNKE.h for high level design overview.
  10. //    You can send comments or suggestions to psichel@sustworks.com
  11. //    The companion IPNetSentryX controller application is available from
  12. //        http://www.sustworks.com
  13. //
  14. // ---------------------------------------------------------------------------------
  15. //    Portions Copyright (c) 1999-2002 Apple Computer, Inc. All Rights Reserved.
  16. //
  17. //    This file contains Original Code and/or Modifications of Original Code as defined
  18. //    in and that are subject to the Apple Public Source License Version 1.2 (the 'License').
  19. //    You may not use this file except in compliance with the License.
  20. //    Please obtain a copy of the License at http://www.apple.com/publicsource
  21. //    and read it before using this file.
  22. //
  23. //    The Original Code and all software distributed under the License are distributed
  24. //    on an 'AS IS' basis, WITHOUT WARRANTY OF ANY KIND, EITHER EXPRESS OR IMPLIED,
  25. //    AND APPLE HEREBY DISCLAIMS ALL SUCH WARRANTIES, INCLUDING WITHOUT LIMITATION,
  26. //    ANY WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE, QUIET
  27. //    ENJOYMENT OR NON-INFRINGEMENT. Please see the License for the specific
  28. //    language governing rights and limitations under the License." 
  29. // ---------------------------------------------------------------------------------
  30.  
  31. #define DEBUG_IPK 0
  32. // Tiger kpi (socket filter)
  33. #include <mach/vm_types.h>
  34. #include <mach/kmod.h>
  35. #include <sys/socket.h>
  36. #include <sys/kpi_socketfilter.h>
  37. #include <netinet/in.h>
  38.  
  39. // Tiger kpi (interface filter)
  40. #include <mach/mach_types.h>
  41. #include <sys/systm.h>
  42. #include <sys/queue.h>
  43. #include <sys/malloc.h>
  44. #include <sys/kpi_mbuf.h>
  45. #define _IP_VHL
  46. #include <netinet/in_systm.h>
  47. //#include <netinet/in.h>
  48. #include <netinet/ip.h>
  49. #include <netinet/ip6.h>
  50. #include <netinet/kpi_ipfilter.h>
  51. #include <net/kpi_interfacefilter.h>
  52. void iflt_detach(interface_filter_t filter_ref);
  53.  
  54. #include <sys/param.h>
  55. #include <sys/systm.h>
  56.  
  57. //#include <sys/socket.h>
  58. //#include <sys/protosw.h>
  59. //#include <sys/socketvar.h>
  60.  
  61. #include <sys/fcntl.h>
  62. //#include <sys/malloc.h>
  63. #include <sys/queue.h>
  64. #include <sys/domain.h>
  65. #include <sys/mbuf.h>
  66. #include <sys/kern_event.h>
  67. #include <net/route.h>
  68. #include <net/if.h>
  69. #include <net/if_types.h>
  70. #include <net/if_dl.h>
  71. #include <net/ndrv.h>
  72. #include <net/kext_net.h>
  73. #include <net/dlil.h>
  74. //#include <netinet/in.h>        // Needed for (*&^%$#@ arpcom in if_arp.h
  75. #include <net/ethernet.h>
  76. #include <net/if_arp.h>
  77. #include <machine/spl.h>
  78. #include <kern/thread.h>
  79. #include <libkern/OSAtomic.h>
  80. #include <libkern/OSTypes.h>
  81. #include <string.h>
  82.  
  83. #include "IPNetSentry_TNKE.h"
  84. #include "IPTypes.h"
  85. #include "kft.h"
  86. #include "kftDelay.h"
  87. #include "kftTrigger.h"
  88. #include "kftConnectionTable.h"
  89. #ifdef IPNetRouter
  90. #include "kftPortMapTable.h"
  91. #include "kftNatTable.h"
  92. #endif
  93. #include "FilterTypes.h"
  94.  
  95. // tag packets so we can recognize re-injected ones
  96. #define MY_BUNDLE_ID "com.sustworks.kext.IPNetSentry_TNKE"
  97. #define MY_TAG_TYPE 1
  98. // tag associated with this kext for use in marking packets that have been previously processed
  99. static mbuf_tag_id_t    gidtag;
  100.  
  101. int     memcmp(const void *, const void *, size_t);
  102.  
  103. // macro to convert kernel to external socket
  104. //#define sotoextcb(so) (struct kextcb *)(so->so_ext)
  105.  
  106. //extern void kprintf(const char *, ...);
  107.  
  108. //
  109. //    Forward function declarations
  110. //        Use unix style names (words separated by "_") for intercepts and callbacks
  111. //        Use Mac style names for internal functions (initial caps)
  112. //        Use ipk_ or ik_ prefix to avoid kernel name space conflicts
  113. //        ipk_ for PF_NKE and DLIL filter functions, ik_ for socket functions
  114. //
  115. // Tiger NKE socket intercepts
  116. static void ik_unregistered(sflt_handle handle);
  117. static errno_t ik_attach(void **cookie, socket_t so);
  118. static void    ik_detach(void *cookie, socket_t so);
  119. static void ik_notify(void *cookie, socket_t so, sflt_event_t event, void *param);
  120. static int ik_getpeername(void *cookie, socket_t so, struct sockaddr **sa);
  121. static int ik_getsockname(void *cookie, socket_t so, struct sockaddr **sa);
  122. static errno_t ik_data_in(void *cookie, socket_t so,
  123.                     const struct sockaddr *from, mbuf_t *data,
  124.                     mbuf_t *control, sflt_data_flag_t flags);
  125. static errno_t ik_data_out(void *cookie, socket_t so,
  126.                     const struct sockaddr *to, mbuf_t *data,
  127.                     mbuf_t *control, sflt_data_flag_t flags);
  128. static errno_t ik_connect_in(void *cookie, socket_t so, const struct sockaddr *from);
  129. static errno_t ik_connect_out(void *cookie, socket_t so, const struct sockaddr *to);
  130. static errno_t ik_bind(void *cookie, socket_t so, const struct sockaddr *to);
  131. static errno_t ik_setoption(void *cookie, socket_t so, sockopt_t opt);
  132. static errno_t ik_getoption(void *cookie, socket_t so, sockopt_t opt);
  133. static errno_t ik_listen(void *cookie, socket_t so);
  134. static errno_t ik_ioctl(void *cookie, socket_t so, u_int32_t request, const char* argp);
  135.  
  136. // Tiger socket filter module wide state
  137. static int registered = 0;
  138. static int unregistered_started = 0;
  139. static int unregistered_complete = 0;
  140.  
  141. // Dispatch vector for Tiger socket intercepts
  142. static struct sflt_filter ik_sflt_filter = {
  143.     IPNetSentry_TNKE_Handle,
  144.     SFLT_PROG,
  145.     "com.sustworks.kext.IPNetSentry_TNKE",
  146.     
  147.     ik_unregistered,
  148.     ik_attach,
  149.     ik_detach,
  150.     
  151.     ik_notify,
  152.     ik_getpeername,
  153.     ik_getsockname,
  154.     ik_data_in,
  155.     ik_data_out,
  156.     ik_connect_in,
  157.     ik_connect_out,
  158.     ik_bind,
  159.     ik_setoption,
  160.     ik_getoption,
  161.     ik_listen,
  162.     ik_ioctl
  163. };
  164.  
  165. // mutex lock for synchronizeing NKE data between kernel threads
  166. static lck_mtx_t *tnke_lock;
  167. static lck_grp_t *tnke_lock_grp = 0;
  168.  
  169. // Tiger protocol filter intercpets
  170. static errno_t ipk_ipf_input_func(caddr_t cookie, mbuf_t *data, int hlen, u_int8_t protocol);
  171. static errno_t ipk_ipf_output_func(caddr_t cookie, mbuf_t *data, ipf_pktopts_t options);
  172. static void ipk_ipf_detach_func(caddr_t cookie);
  173.  
  174. // Tiger interface filter intercepts
  175. static void ipk_iff_detached_func(
  176.     void* cookie, 
  177.     ifnet_t interface);
  178. static void ipk_iff_event_func(
  179.     void* cookie, 
  180.     ifnet_t interface, 
  181.     protocol_family_t protocol, 
  182.     const struct kev_msg *event_msg);
  183. static errno_t ipk_iff_input_func(
  184.     void*cookie, 
  185.     ifnet_t interface, 
  186.     protocol_family_t protocol, 
  187.     mbuf_t *data, 
  188.     char **frame_ptr);
  189. static errno_t ipk_iff_ioctl_func(
  190.     void*cookie,
  191.     ifnet_t interface,
  192.     protocol_family_t protocol, 
  193.     u_long ioctl_cmd,
  194.     void*ioctl_arg);
  195. static errno_t ipk_iff_output_func(
  196.     void*cookie,
  197.     ifnet_t interface,
  198.     protocol_family_t protocol, 
  199.     mbuf_t *data);
  200.     
  201. // internal support functions
  202. static int ik_connect(socket_t cso);
  203. static void ik_disconnect(socket_t cso);
  204.  
  205. static int ik_attachCount(int controlIndex);
  206. static int ik_controlCount(int attachIndex);
  207. static int ik_controlIndexForSocket(socket_t so);
  208. static int ik_emptyControlIndex();
  209. static int ik_attachIndexForName(char *inName);
  210. static int ik_emptyAttachIndex();
  211. static int ik_detachController(int controlIndex);
  212. static int ik_detachInterface(int attachIndex);
  213.  
  214. // timer callback
  215. static void ipk_timeout(void *cookie);
  216. // timer schedule
  217. static void ipk_setTimer();
  218. // send message to controlling socket
  219. void PROJECT_sendMessage(socket_t ctl, ipk_message_t *message);
  220.  
  221. //
  222. // Global structures and data storage
  223. //
  224. // max size of drop Response
  225. #define KFT_dropResponseMax 1000
  226. // drop Connection response
  227. u_int8_t PROJECT_dropResponseBuffer[KFT_dropResponseMax];
  228. int PROJECT_dropResponseLength;
  229. // time of day info
  230. sopt_timeParam_t PROJECT_timeOfDay;
  231. // flags
  232. u_int32_t PROJECT_flags;
  233. // timer Ref Count (firewall enabled)
  234. int32_t PROJECT_timerRefCount;
  235.     // ipk_timeout reschedules itself when PROJECT_timerRefCount>0
  236. int PROJECT_doRateLimit;            // packet matched a rate limit rule
  237.     // index of failover requested 0=none, 1=default, 2=alternate gateway
  238. int PROJECT_failoverRequest;
  239.     // reserve bandwidth info
  240. KFT_reserveInfo_t PROJECT_rReserveInfo;
  241. KFT_reserveInfo_t PROJECT_sReserveInfo;
  242.  
  243.  
  244. //
  245. // Module wide variables (not exported)
  246. //
  247. static int32_t ipk_timerPending;
  248. static int ipk_initted = 0;
  249.  
  250.  
  251. //
  252. // Setup per instance structures and storage
  253. //
  254.  
  255. // maximum number of controllers and DLIL attachments use index values 1..n
  256. // 0 is reserved for "not found"
  257. //#define kMaxControl    8
  258. //#define kMaxAttach 8
  259.  
  260. // Array of controller instances
  261. control_t PROJECT_control[kMaxControl+1];
  262.  
  263. // Global Array of DLIL attach instances
  264. attach_t PROJECT_attach[kMaxAttach+1];
  265.  
  266.  
  267. #pragma mark -- Load and unload kernel extension
  268. //
  269. // Load and unload kernel extension
  270. //
  271. // ---------------------------------------------------------------------------------
  272. //    Ñ IPNetSentry_TNKE_start
  273. // ---------------------------------------------------------------------------------
  274. kern_return_t IPNetSentry_TNKE_start (kmod_info_t * ki, void * data)
  275. {
  276.     int returnValue = KERN_SUCCESS;
  277.     errno_t status;
  278.     lck_grp_attr_t *grp_attributes = 0;
  279.     lck_attr_t *lck_attributes = 0;
  280.     int i;
  281.     
  282.     printf("IPNetSentry_TNKE has loaded!\n");
  283.  
  284.     // set up the tag value associated with this NKE to mark previously seen packets
  285.     status = mbuf_tag_id_find(MY_BUNDLE_ID, &gidtag);
  286.     if (status != 0) {
  287.         printf("IPNetSentry_TNKE_start: mbuf_tag_id_find failed %d\n", status);
  288.         return KERN_FAILURE;
  289.     }
  290.  
  291.     // Allocate a mutex lock
  292.     grp_attributes = lck_grp_attr_alloc_init();
  293.     lck_grp_attr_setdefault(grp_attributes);
  294.     tnke_lock_grp = lck_grp_alloc_init("IPNetSentry_TNKE", grp_attributes);
  295.     lck_grp_attr_free(grp_attributes);
  296.     grp_attributes = 0;
  297.  
  298.     lck_attributes = lck_attr_alloc_init();
  299.     lck_attr_setdefault(lck_attributes);
  300.     lck_attr_setdebug(lck_attributes);
  301.  
  302.     tnke_lock = lck_mtx_alloc_init(tnke_lock_grp, lck_attributes);
  303.  
  304.     lck_attr_free(lck_attributes);
  305.     lck_attributes = 0;
  306.  
  307.     // mutex lock
  308.     lck_mtx_lock(tnke_lock);
  309.     do {
  310.         // already initialized?
  311.         if (ipk_initted) break;
  312.         
  313.         // initialize global storage
  314.         PROJECT_timerRefCount = 0;
  315.         ipk_timerPending = 0;
  316.         PROJECT_timeOfDay.timeStamp = 0;
  317.         PROJECT_flags = 0;
  318.         PROJECT_dropResponseLength = 0;
  319.         
  320.         // initialize our instance storage
  321.         for (i=0; i<=kMaxControl; i++) {
  322.             bzero(&PROJECT_control[i], sizeof(control_t));
  323.         }
  324.         for (i=0; i<=kMaxAttach; i++) {
  325.             bzero(&PROJECT_attach[i], sizeof(attach_t));
  326.         }
  327.         // setup KFT structures
  328.         KFT_init();
  329.                 
  330.         // register our NKE
  331.         status = sflt_register(&ik_sflt_filter, PF_INET,
  332.                       SOCK_DGRAM, IPPROTO_UDP);
  333.  
  334.         if (status != 0) {
  335.             printf("IPNetSentry_TNKE_start: sflt_register failed %d\n", status);
  336.             returnValue = KERN_FAILURE;
  337.         } else {
  338.             registered++;
  339.             ipk_initted = 1;
  340.         }
  341.         
  342.     } while (FALSE);
  343.     // mutex unlock
  344.     lck_mtx_unlock(tnke_lock);
  345.  
  346.     return returnValue;
  347. }
  348.  
  349.  
  350. // ---------------------------------------------------------------------------------
  351. //    Ñ IPNetSentry_TNKE_stop
  352. // ---------------------------------------------------------------------------------
  353. kern_return_t IPNetSentry_TNKE_stop (kmod_info_t * ki, void * data) {
  354.     int returnValue = KERN_SUCCESS;
  355.     errno_t status;
  356.     int i;
  357.  
  358.     // mutex lock
  359.     lck_mtx_lock(tnke_lock);
  360.     do {
  361.         // if not initted
  362.         if (!ipk_initted) break;
  363.         
  364.         // unlink controllers and remove any DLIL attach instances
  365.         for (i=1; i<=kMaxControl; i++) {
  366.             if (PROJECT_control[i].ctl != 0) {
  367.                 ik_detachController(i);
  368.                 // tell any clients the socket has gone away
  369.                 // not sure how to do this, so just fail for now
  370.                 returnValue = KERN_FAILURE;    // fail until all sockets are disconnected
  371.                 break;
  372.             }
  373.         }
  374.         if (returnValue != 0) break;
  375.         
  376.         // remove any remaining attach instances (defensive)
  377.         for (i=1; i<=kMaxAttach; i++) {
  378.             if (PROJECT_attach[i].ifFilterRef || PROJECT_attach[i].ipFilterRef) {
  379.                 ik_detachInterface(i);
  380.             }
  381.         }
  382.         
  383.         // release KFT structures
  384.         KFT_terminate();
  385.         
  386.         // need to cancel any pending kernel callbacks (timeout)
  387.             // fortunately we don't normally unload and can warn the user
  388.             // not to unload while any tools are running
  389.         // force timer ref count to zero
  390.         if (PROJECT_timerRefCount || ipk_timerPending) {
  391.             bsd_untimeout(ipk_timeout, (void *)0);
  392.             PROJECT_timerRefCount = 0;
  393.         }
  394.         
  395.         // unplug our socket filter
  396.         if (unregistered_started == 0) {
  397.             status = sflt_unregister(ik_sflt_filter.sf_handle);
  398.             if (status != 0) {
  399.                 printf("IPNetSentry_TNKE_stop: sflt_unregister failed %d\n", status);
  400.                 returnValue = KERN_FAILURE;
  401.             }
  402.             else {
  403.                 unregistered_started++;
  404.             }
  405.         } else if (unregistered_complete) {
  406.             returnValue = KERN_SUCCESS;
  407.             ipk_initted = 0;
  408.         } else {
  409.             printf("IPNetSentry_TNKE_stop: again\n");
  410.             returnValue = KERN_FAILURE;
  411.         }
  412.     } while (FALSE);
  413.     // mutex unlock
  414.     lck_mtx_unlock(tnke_lock);
  415.     
  416.     // release mutex lock
  417.     if (returnValue == KERN_SUCCESS) {
  418.         if (tnke_lock)
  419.             lck_mtx_free(tnke_lock, tnke_lock_grp);
  420.         if (tnke_lock_grp)
  421.             lck_grp_free(tnke_lock_grp);
  422.         tnke_lock = 0;
  423.         tnke_lock_grp = 0;
  424.     }
  425.     
  426.     if (returnValue == 0) printf("IPNetSentry_TNKE has unloaded!\n");
  427.  
  428.     return returnValue;
  429. }
  430.  
  431. #pragma mark -- Tiger socket intercept functions --
  432.  
  433. static void 
  434. ik_unregistered(sflt_handle handle)
  435. {
  436.     unregistered_complete++;
  437.     return;
  438. }
  439.  
  440. static errno_t    
  441. ik_attach(void **cookie, socket_t so)
  442. {
  443.     //printf("ik_attach: %x\n", so);
  444.     return 0;
  445. }
  446.  
  447. static void    
  448. ik_detach(void *cookie, socket_t so)
  449. {
  450.     //printf("ik_detach: %x\n", so);
  451.     return;
  452. }
  453.  
  454. // this is where we get notified that a socket is closing
  455. static void ik_notify(void *cookie, socket_t so,
  456.                          sflt_event_t event, void *param)
  457. {
  458.     //printf("ik_notify: %x event: %lu\n", so, event);
  459.     if (event == sock_evt_closing) {
  460.         // socket is being closed:
  461.         //     disconnect, turn off monitoring, and detach from interface if no more references.
  462.         // - Any open sockets will be closed by the kernel when the process quits,
  463.         //   so this is our big chance to clean up properly regardless of how the
  464.         //   companion application died.
  465.         ik_disconnect(so);
  466.     }
  467.     return;
  468. }
  469.  
  470. static int
  471. ik_getpeername(void *cookie, socket_t so,
  472.                          struct sockaddr **sa)
  473. {
  474.     return 0;
  475. }
  476.  
  477. static int
  478. ik_getsockname(void *cookie, socket_t so,
  479.                          struct sockaddr **sa)
  480. {
  481.     return 0;
  482. }
  483.  
  484.  
  485. static errno_t    
  486. ik_data_in(void *cookie, socket_t so,
  487.                     const struct sockaddr *from, mbuf_t *data,
  488.                     mbuf_t *control, sflt_data_flag_t flags)
  489. {
  490.     return 0;
  491. }
  492.  
  493. static errno_t
  494. ik_data_out(void *cookie, socket_t so,
  495.                     const struct sockaddr *to, mbuf_t *data,
  496.                     mbuf_t *control, sflt_data_flag_t flags)
  497. {
  498.     return 0;
  499. }
  500.  
  501.  
  502. static errno_t
  503. ik_connect_in(void *cookie, socket_t so,
  504.                     const struct sockaddr *from)
  505. {
  506.     printf("ik_connect_in: %x\n", so);
  507.     return 0;
  508. }
  509.  
  510. static errno_t    
  511. ik_connect_out(void *cookie, socket_t so,
  512.                     const struct sockaddr *to)
  513. {
  514.     printf("ik_connect_in: %x\n", so);
  515.     return 0;
  516. }
  517.  
  518. static errno_t
  519.     ik_bind(void *cookie, socket_t so,
  520.                     const struct sockaddr *to)
  521. {
  522.     return 0;
  523. }
  524.  
  525. // ---------------------------------------------------------------------------------
  526. //    Ñ ik_setoption
  527. // ---------------------------------------------------------------------------------
  528. // intercept socket options (soset and soget)
  529. static errno_t
  530. ik_setoption(void *cookie, socket_t so, sockopt_t sopt)
  531. {
  532.     errno_t returnValue = 0;    // continue normall processing (pass it on)
  533.     errno_t status;
  534.     int controlIndex=0;
  535.     int attachIndex=0;
  536.     int32_t count;
  537.     int valsize, howMany;
  538.  
  539.     do {
  540.         // find our controller instance
  541.         controlIndex = ik_controlIndexForSocket(so);
  542.         if (!controlIndex) {
  543.             // not yet connected, try to connect
  544.             returnValue = ik_connect(so);
  545.             if (returnValue != EJUSTRETURN) break;
  546.             controlIndex = ik_controlIndexForSocket(so);
  547.             if (!controlIndex) {
  548.                 returnValue = ENOTCONN;
  549.                 break;
  550.             }
  551.         }
  552.  
  553.         switch(sockopt_name(sopt)) {
  554.             case SO_ATTACH_LINK:
  555.                 // mutex lock
  556.                 lck_mtx_lock(tnke_lock);
  557.                 do {
  558.                     // attach a controller socket to an IP interface (data link)
  559.                     struct sopt_attachParam attachParam;
  560.                     // Reference: copyin and copyout option parameters
  561.                     //errno_t sockopt_copyin(sockopt_t sopt, void *data, size_t length);
  562.                     //errno_t sockopt_copyout(sockopt_t sopt, void *data, size_t length);
  563.                     #if DEBUG_IPK
  564.                         printf("ik_setoption: received SO_ATTACH_LINK\n");
  565.                     #endif
  566.                     // copyin option parameter
  567.                     returnValue = sockopt_copyin(sopt, &attachParam, sizeof(attachParam));
  568.                     if (returnValue != 0) break;
  569.                     
  570.                     // look for existing DLIL attach by bsdName
  571.                     attachIndex = ik_attachIndexForName(attachParam.bsdName);
  572.                     if (attachIndex) {
  573.                         // found existing DLIL attach
  574.                         // associate this controller with DLIL attach
  575.                         PROJECT_control[controlIndex].attachMap[attachIndex] = 1;
  576.                         returnValue = EJUSTRETURN;
  577.                         break;            
  578.                     }                                    
  579.                     // did not find previous attachment
  580.                     // create a new DLIL attach instance for requested interface
  581.                             // find slot for attach instance
  582.                     attachIndex = ik_emptyAttachIndex();
  583.                     if (!attachIndex) {
  584.                         returnValue = EBUSY;
  585.                         break;
  586.                     }
  587.                     bzero(&PROJECT_attach[attachIndex], sizeof(attach_t));
  588.                     // remember our own index for convenience
  589.                     PROJECT_attach[attachIndex].attachIndex = attachIndex;
  590.                     
  591.                     if (attachParam.protocolFilter) {
  592.                         // Register IPv4 protocol filter
  593.                         struct ipf_filter ipf_filter;
  594.                         ipfilter_t ipFilterRef;
  595.                             // set cookie to point to this attach instance
  596.                         ipf_filter.cookie = (caddr_t)&PROJECT_attach[attachIndex];
  597.                         ipf_filter.name = "com.sustworks.nke.IPNetSentry_TNKE";
  598.                         ipf_filter.ipf_input = (ipf_input_func)ipk_ipf_input_func;
  599.                         ipf_filter.ipf_output = (ipf_output_func)ipk_ipf_output_func;
  600.                         ipf_filter.ipf_detach = (ipf_detach_func)ipk_ipf_detach_func;
  601.                              // attach as IP filter
  602.                         returnValue = ipf_addv4(&ipf_filter, &ipFilterRef);
  603.                         PROJECT_attach[attachIndex].ipFilterRef = ipFilterRef;
  604.                         if (returnValue != 0) {
  605.                             printf("ik_setoption attach: ipf_addv4 failed %d\n", returnValue);
  606.                             break;
  607.                         } else {
  608.                             #if DEBUG_IPK
  609.                             printf("ik_setoption: protocol filter on %s\n", attachParam.bsdName);
  610.                             #endif
  611.                         }
  612.                     }
  613.                     else {
  614.                         // Register as interface filter
  615.                         ifnet_t ifnet_ref = NULL;
  616.                         struct iff_filter iff_filter;
  617.                         interface_filter_t ifFilterRef;
  618.                         // find matching ifnet for interface name (must call ifnet_release)
  619.                         returnValue = ifnet_find_by_name(attachParam.bsdName, &ifnet_ref);
  620.                         if (returnValue != 0) break;
  621.                             // set cookie to point to this attach instance
  622.                         iff_filter.iff_cookie = (caddr_t)&PROJECT_attach[attachIndex];
  623.                         iff_filter.iff_name = "com.sustworks.nke.IPNetSentry_TNKE";
  624.                         //iff_filter.iff_protocol = PF_INET;
  625.                         iff_filter.iff_protocol = 0;    // bridge non PF_INET packets
  626.                         iff_filter.iff_input = ipk_iff_input_func;
  627.                         iff_filter.iff_output = ipk_iff_output_func;
  628.                         iff_filter.iff_event = ipk_iff_event_func;
  629.                         iff_filter.iff_ioctl = ipk_iff_ioctl_func;
  630.                         iff_filter.iff_detached = ipk_iff_detached_func;
  631.                         // attach as interface filter
  632.                         returnValue = iflt_attach(ifnet_ref, &iff_filter, &ifFilterRef);
  633.                         PROJECT_attach[attachIndex].ifFilterRef = ifFilterRef;
  634.                         // remember the ifnet we found (release when detaching)
  635.                         PROJECT_attach[attachIndex].ifnet_ref = ifnet_ref;
  636.                         //if (ifnet_ref) ifnet_release(ifnet_ref);
  637.                         if (returnValue != 0) {
  638.                             printf("ik_setoption attach: iflt_attached failed %d\n", returnValue);
  639.                             break;
  640.                         } else {
  641.                             #if DEBUG_IPK
  642.                             printf("ik_setoption: interface filter on %s\n", attachParam.bsdName);
  643.                             #endif
  644.                         }
  645.                     }
  646.  
  647.                     // remember other attach info
  648.                     {
  649.                         int len;
  650.                         // default to filter on
  651.                         PROJECT_attach[attachIndex].kftInterfaceEntry.filterOn = 1;
  652.                         // remember interface name as CString
  653.                         len = strlen(attachParam.bsdName);
  654.                         memcpy(&PROJECT_attach[attachIndex].kftInterfaceEntry.bsdName[0],
  655.                                         &attachParam.bsdName[0], len+1);
  656.                         // associate this controller with DLIL attach
  657.                         PROJECT_control[controlIndex].attachMap[attachIndex] = 1;
  658.                         #if DEBUG_IPK
  659.                                 printf("ik_setoption control instance: %d attach instance: %d\n",
  660.                                         controlIndex, attachIndex);
  661.                         #endif
  662.                     }
  663.                     // Everything worked, Yay!
  664.                     returnValue = EJUSTRETURN;                    
  665.                 } while (FALSE);
  666.                 // mutex unlock
  667.                 lck_mtx_unlock(tnke_lock);
  668.                 break;
  669.             case SO_DETACH_LINK:
  670.                 // mutex lock
  671.                 lck_mtx_lock(tnke_lock);
  672.                 do {
  673.                     // detach specified interface from controller socket
  674.                     struct sopt_attachParam attachParam;
  675.                     #if DEBUG_IPK
  676.                         printf("ik_setoption: received SO_DETACH_LINK\n");
  677.                     #endif
  678.                     // if name is nil, detach controller and any interface attachments
  679.                     if (sockopt_valsize(sopt) == 0) {
  680.                         #if DEBUG_IPK
  681.                             printf("ik_setoption detach all interfaces\n");
  682.                         #endif
  683.                         returnValue = ik_detachController(controlIndex);
  684.                         if (returnValue != 0) break;
  685.                         returnValue = EJUSTRETURN;
  686.                         break;
  687.                     }
  688.                     // copyin option parameter
  689.                     returnValue = sockopt_copyin(sopt, &attachParam, sizeof(attachParam));
  690.                     if (returnValue != 0) break;
  691.                     // make sure delay table is empty before detaching from any interfaces
  692.                     //KFT_delayAge(0);                
  693.                     // look for existing DLIL attach by bsdName
  694.                     attachIndex = ik_attachIndexForName(attachParam.bsdName);
  695.                     if (attachIndex) {
  696.                         // found existing DLIL attach
  697.                         // dis-associate this controller with attach
  698.                         PROJECT_control[controlIndex].attachMap[attachIndex] = 0;
  699.                         // are there any more references?
  700.                         if (ik_controlCount(attachIndex) == 0) {
  701.                             // no more references to this attach instance
  702.                             ik_detachInterface(attachIndex);
  703.                         }
  704.                     }
  705.                     else {
  706.                         returnValue = ENOENT;
  707.                         break;
  708.                     }
  709.                     returnValue = EJUSTRETURN;
  710.                 } while (FALSE);
  711.                 // mutex unlock
  712.                 lck_mtx_unlock(tnke_lock);
  713.                 break;
  714.             case SO_MONITOR_ON:
  715.                 do {
  716.                     #if DEBUG_IPK
  717.                         printf("ik_setoption: received SO_MONITOR_ON\n");
  718.                     #endif
  719.                     // reset nkeSends to tell NKE we want more
  720.                     PROJECT_control[controlIndex].nkeSends = 0;
  721.                     // check for attachment to an interface
  722.                     if (ik_attachCount(controlIndex) == 0) {
  723.                         returnValue = ENOENT;
  724.                         break;
  725.                     }
  726.                     // if monitoring is not already on
  727.                     if (PROJECT_control[controlIndex].monitorOn == 0) {
  728.                         int32_t result;
  729.                         PROJECT_control[controlIndex].monitorOn = 1;
  730.                         // start 1-second timer to send interface stats upstream
  731.                         //PROJECT_timerRefCount += 1;
  732.                         result = OSAddAtomic(1, (SInt32*)&PROJECT_timerRefCount);
  733.                         result = OSAddAtomic(1, (SInt32*)&ipk_timerPending);
  734.                         if (result == 0) {    // timer is not running
  735.                             #if DEBUG_IPK
  736.                                 printf("ik_setoption: start timer\n");
  737.                             #endif
  738.                             ipk_timeout((void *)0);
  739.                         }
  740.                     }
  741.                     returnValue = EJUSTRETURN;
  742.                 } while (FALSE);
  743.                 break;
  744.             case SO_MONITOR_OFF:
  745.                 do {
  746.                     #if DEBUG_IPK
  747.                         printf("ik_setoption: received SO_MONITOR_OFF\n");
  748.                     #endif
  749.                     PROJECT_control[controlIndex].monitorOn = 0;
  750.                     // bump timer ref count
  751.                     //PROJECT_timerRefCount -= 1;
  752.                     status = OSAddAtomic(-1, (SInt32*)&PROJECT_timerRefCount);
  753.                     if (status <= 0) PROJECT_timerRefCount = 0;    // defensive
  754.                     // report current connection table
  755.                     {
  756.                         // mutex lock
  757.                         lck_mtx_lock(tnke_lock);
  758.                         // do report
  759.                         KFT_connectionReport();
  760.                         // mutex unlock
  761.                         lck_mtx_unlock(tnke_lock);                    
  762.                     }
  763.                     returnValue = EJUSTRETURN;
  764.                 } while (FALSE);
  765.                 break;
  766.             case SO_FILTER_DOWNLOAD:
  767.                 // filter table is downloaded as binary array of table entries
  768.                 // mutex lock
  769.                 lck_mtx_lock(tnke_lock);
  770.                 do {
  771.                     #if DEBUG_IPK
  772.                         printf("ik_setoption: received SO_FILTER_DOWNLOAD\n");
  773.                     #endif
  774.                     // check option length
  775.                     kft_filterTableD.length = sockopt_valsize(sopt);
  776.                     if (kft_filterTableD.length >= kft_filterTableD.bufferLength) {
  777.                         kft_filterTableD.length = kft_filterTableD.bufferLength;
  778.                         #if DEBUG_IPK
  779.                         printf("SO_FILTER_DOWNLOAD buffer space exceeded.\n");
  780.                         #endif
  781.                         returnValue = EMSGSIZE;
  782.                         break;
  783.                     }
  784.                     // copyin option parameter
  785.                     returnValue = sockopt_copyin(sopt, kft_filterTableD.bytes, kft_filterTableD.length);
  786.                     if (returnValue != 0) break;
  787.                     #if DEBUG_IPK
  788.                         printf("ik_setoption: sooptcopyin OK\n");
  789.                     #endif
  790.                     kft_filterTableD.offset = kft_filterTableD.length/sizeof(KFT_filterEntry_t);
  791.                     returnValue = EJUSTRETURN;
  792.                 } while (FALSE);
  793.                 // mutex unlock
  794.                 lck_mtx_unlock(tnke_lock);
  795.                 break;
  796.             case SO_KFT_RESET: {
  797.                 #if DEBUG_IPK
  798.                     printf("ik_setoption: received SO_KFT_RESET\n");
  799.                 #endif
  800.                 // mutex lock
  801.                 lck_mtx_lock(tnke_lock);
  802.                 // reset selected state before downloading
  803.                 KFT_reset();
  804.                 // mutex unlock
  805.                 lck_mtx_unlock(tnke_lock);
  806.                 returnValue = EJUSTRETURN;
  807.                 break;
  808.             }
  809.             case SO_FILTER_UPLOAD: {
  810.                 #if DEBUG_IPK
  811.                     printf("ik_setoption: received SO_FILTER_UPLOAD\n");
  812.                 #endif
  813.                 returnValue = sockopt_copyout(sopt, kft_filterTableD.bytes, kft_filterTableD.length);
  814.                 if (returnValue != 0) break;
  815.                 #if DEBUG_IPK
  816.                     printf("ik_setoption: sooptcopyout OK %d\n",outBuf.length);
  817.                 #endif
  818.                 returnValue = EJUSTRETURN;
  819.                 break;
  820.             }
  821.             case SO_FILTER_COUNT: {
  822.                 #if DEBUG_IPK
  823.                     printf("ik_setoption: received SO_FILTER_COUNT\n");
  824.                 #endif
  825.                 count = KFT_filterCount();
  826.                 returnValue = sockopt_copyout(sopt, &count, sizeof(count));
  827.                 if (returnValue != 0) break;
  828.                 returnValue = EJUSTRETURN;
  829.                 break;
  830.             }
  831.             case SO_TRIGGER_COUNT: {
  832.                 #if DEBUG_IPK
  833.                     printf("ik_setoption: received SO_TRIGGER_COUNT\n");
  834.                 #endif
  835.                 count = KFT_triggerCount();
  836.                 returnValue = sockopt_copyout(sopt, &count, sizeof(count));
  837.                 if (returnValue != 0) break;
  838.                 returnValue = EJUSTRETURN;
  839.                 break;
  840.             }
  841.             case SO_INTERFACE_COUNT: {
  842.                 #if DEBUG_IPK
  843.                     printf("ik_setoption: received SO_INTERFACE_COUNT\n");
  844.                 #endif
  845.                 count = ik_attachCount(controlIndex);
  846.                 returnValue = sockopt_copyout(sopt, &count, sizeof(count));
  847.                 if (returnValue != 0) break;
  848.                 returnValue = EJUSTRETURN;
  849.                 break;
  850.             }
  851. #ifdef IPNetRouter
  852.             case SO_PORTMAP_COUNT: {
  853.                 #if DEBUG_IPK
  854.                     printf("ik_setoption: received SO_PORTMAP_COUNT\n");
  855.                 #endif
  856.                 count = KFT_portMapCount();
  857.                 returnValue = sockopt_copyout(sopt, &count, sizeof(count));
  858.                 if (returnValue != 0) break;
  859.                 returnValue = EJUSTRETURN;
  860.                 break;
  861.             }
  862. #endif
  863.             case SO_SET_TIME: {
  864.                 // set time of day info for NKE
  865.                 #if DEBUG_IPK
  866.                     printf("ik_setoption: received SO_SET_TIME\n");
  867.                 #endif
  868.                 // copyin option parameter
  869.                 returnValue = sockopt_copyin(sopt, &PROJECT_timeOfDay, sizeof(struct sopt_timeParam));
  870.                 if (returnValue != 0) break;
  871.                 returnValue = EJUSTRETURN;
  872.                 break;
  873.             }
  874.             
  875.             case SO_SET_FLAGS: {
  876.                 // set global NKE flags
  877.                 sopt_flagsParam_t flagsParam;
  878.                 // copyin option parameter
  879.                 returnValue = sockopt_copyin(sopt, &flagsParam, sizeof(struct sopt_flagsParam));
  880.                 if (returnValue != 0) break;
  881.                 PROJECT_flags &= ~flagsParam.mask;    // clear bits we're going to modify
  882.                 PROJECT_flags |= flagsParam.flags;    // set bits to effect change
  883.                 returnValue = EJUSTRETURN;
  884.                 #if DEBUG_IPK
  885.                     KFT_logText("ik_setoption: received SO_SET_FLAGS ", &PROJECT_flags);
  886.                 #endif
  887.                 break;
  888.             }
  889.             case SO_GET_FLAGS: {
  890.                 // get global NKE flags
  891.                 sopt_flagsParam_t flagsParam;
  892.                 flagsParam.flags = PROJECT_flags;
  893.                 flagsParam.mask = 0xFFFFFFFF;
  894.                 // return current value
  895.                 returnValue = sockopt_copyout(sopt, &flagsParam, sizeof(flagsParam));
  896.                 if (returnValue != 0) break;
  897.                 returnValue = EJUSTRETURN;
  898.                 break;
  899.             }
  900.             
  901.             case SO_DROP_RESPONSE: {
  902.                 #if DEBUG_IPK
  903.                     printf("ik_setoption: received SO_DROP_RESPONSE\n");
  904.                 #endif
  905.                 // check length of option parameter
  906.                 PROJECT_dropResponseLength = sockopt_valsize(sopt);
  907.                 if (PROJECT_dropResponseLength < KFT_dropResponseMax-60) {
  908.                     // copyin option parameter
  909.                     // leave room for link header, ip header, tcp header
  910.                     returnValue = sockopt_copyin(sopt, &PROJECT_dropResponseBuffer[60], PROJECT_dropResponseLength);
  911.                     if (returnValue != 0) break;
  912.                 }
  913.                 else {
  914.                     returnValue = E2BIG;
  915.                     break;
  916.                 }
  917.                 #if DEBUG_IPK
  918.                     printf("ik_setoption: sooptcopyin OK %d\n",PROJECT_dropResponseLength);
  919.                 #endif
  920.                 returnValue = EJUSTRETURN;
  921.                 break;
  922.             }
  923.             case SO_TRIGGER_DURATION: {
  924.                 #if DEBUG_IPK
  925.                     printf("ik_setoption: received SO_TRIGGER_EXPIRATION\n");
  926.                 #endif
  927.                 // copyin option parameter
  928.                 returnValue = sockopt_copyin(sopt, &count, sizeof(count));
  929.                 if (returnValue != 0) break;
  930.                 count = KFT_triggerDuration(count);
  931.                 // return current value
  932.                 returnValue = sockopt_copyout(sopt, &count, sizeof(count));
  933.                 if (returnValue != 0) break;
  934.                 returnValue = EJUSTRETURN;
  935.                 break;
  936.             }        
  937.             case SO_TRIGGER_ADDRESS: {
  938.                 KFT_triggerKey_t value[101];
  939.                 #if DEBUG_IPK
  940.                     printf("ik_setoption: received SO_TRIGGER_ADDRESS\n");
  941.                 #endif
  942.                 // check parameter size
  943.                 valsize = sockopt_valsize(sopt);
  944.                 if (valsize <= sizeof(KFT_triggerKey_t)*100) {
  945.                     // copyin option parameter
  946.                     returnValue = sockopt_copyin(sopt, value, valsize);
  947.                     if (returnValue != 0) break;
  948.                 }
  949.                 else {
  950.                     returnValue = E2BIG;
  951.                     break;
  952.                 }
  953.                 howMany = valsize/sizeof(KFT_triggerKey_t);
  954.                 // mutex lock
  955.                     lck_mtx_lock(tnke_lock);                
  956.                 KFT_triggerRemoveByKey(value, howMany);
  957.                 // mutex unlock
  958.                     lck_mtx_unlock(tnke_lock);                
  959.                 // are there any more updates to send?
  960.                 KFT_triggerSendUpdates();
  961.                 returnValue = EJUSTRETURN;
  962.                 break;
  963.             }
  964.             case SO_TRIGGER_UPLOAD: {
  965.                 #if DEBUG_IPK
  966.                     printf("ik_setoption: received SO_TRIGGER_UPLOAD\n");
  967.                 #endif
  968.                 // mutex lock
  969.                 lck_mtx_lock(tnke_lock);
  970.                 
  971.                 count = KFT_triggerUpload();
  972.                 sockopt_copyout(sopt, &count, sizeof(count));
  973.  
  974.                 // mutex unlock
  975.                 lck_mtx_unlock(tnke_lock);
  976.                 returnValue = EJUSTRETURN;
  977.                 break;
  978.             }
  979.             case SO_INTERFACE_UPLOAD: {
  980.                 #if DEBUG_IPK
  981.                     printf("ik_setoption: received SO_INTERFACE_UPLOAD\n");
  982.                 #endif
  983.                 // mutex lock
  984.                 lck_mtx_lock(tnke_lock);
  985.                 
  986.                 count = KFT_interfaceUpload();
  987.                 sockopt_copyout(sopt, &count, sizeof(count));
  988.  
  989.                 // mutex unlock
  990.                 lck_mtx_unlock(tnke_lock);
  991.                 returnValue = EJUSTRETURN;
  992.                 break;
  993.             }
  994. #ifdef IPNetRouter
  995.             case SO_PORTMAP_UPLOAD: {
  996.                 #if DEBUG_IPK
  997.                     printf("ik_setoption: received SO_PORTMAP_UPLOAD\n");
  998.                 #endif
  999.                 // mutex lock
  1000.                 lck_mtx_lock(tnke_lock);
  1001.                 
  1002.                 count = KFT_portMapUpload();
  1003.                 sockopt_copyout(sopt, &count, sizeof(count));
  1004.  
  1005.                 // mutex unlock
  1006.                 lck_mtx_unlock(tnke_lock);
  1007.                 returnValue = EJUSTRETURN;
  1008.                 break;
  1009.             }
  1010.             case SO_NAT_UPLOAD: {
  1011.                 #if DEBUG_IPK
  1012.                     printf("ik_setoption: received SO_NAT_UPLOAD\n");
  1013.                 #endif
  1014.                 // mutex lock
  1015.                 lck_mtx_lock(tnke_lock);
  1016.                 
  1017.                 count = KFT_natUpload();
  1018.                 sockopt_copyout(sopt, &count, sizeof(count));
  1019.  
  1020.                 // mutex unlock
  1021.                 lck_mtx_unlock(tnke_lock);
  1022.                 returnValue = EJUSTRETURN;
  1023.                 break;
  1024.             }
  1025. #endif
  1026.             case SO_IPK_MESSAGE: {
  1027.                 // accept ipk_message as downstream data
  1028.                 unsigned char buffer[kUpdateBufferSize];
  1029.                 ipk_message_t* message;
  1030.                 message = (ipk_message_t*)&buffer[0];
  1031.                 #if DEBUG_IPK
  1032.                     printf("ik_setoption: received SO_IPK_MESSAGE\n");
  1033.                 #endif
  1034.                 // check parameter size
  1035.                 valsize = sockopt_valsize(sopt);
  1036.                 if (valsize <= kUpdateBufferSize) {
  1037.                     // copyin option parameter
  1038.                     returnValue = sockopt_copyin(sopt, &buffer[0], valsize);
  1039.                     if (returnValue != 0) break;
  1040.                 }
  1041.                 else {
  1042.                     returnValue = E2BIG;
  1043.                     break;
  1044.                 }
  1045.                 if (valsize < sizeof(ipk_message_t)) break;
  1046.                 // pass along to KFT for processing
  1047.                 KFT_receiveMessage(message);
  1048.                 returnValue = EJUSTRETURN;
  1049.                 break;
  1050.             }
  1051.             default: {
  1052.                 #if DEBUG_IPK
  1053.                     printf("ik_setoption: default unrecognized sopt->sopt_name=%x pass it on\n", sockopt_name(sopt));
  1054.                 #endif
  1055.                 returnValue = 0;
  1056.                 break;
  1057.             }
  1058.         }    // end switch
  1059.     } while (FALSE);
  1060.     #if 0
  1061.         printf("ik_setoption returnValue: %d\n", returnValue);
  1062.     #endif    
  1063.     return returnValue;
  1064. }
  1065.                     
  1066. static errno_t
  1067. ik_getoption(void *cookie, socket_t so, sockopt_t sopt)
  1068. {
  1069.     errno_t returnValue = 0;    // continue normall processing (pass it on)
  1070.     //errno_t status;
  1071.     int controlIndex=0;
  1072.     //int attachIndex=0;
  1073.     int32_t count;
  1074.  
  1075.     do {
  1076.         // find our controller instance
  1077.         controlIndex = ik_controlIndexForSocket(so);
  1078.         if (!controlIndex) {
  1079.             // not yet connected, try to connect
  1080.             returnValue = ik_connect(so);
  1081.             if (returnValue != EJUSTRETURN) break;
  1082.             controlIndex = ik_controlIndexForSocket(so);
  1083.             if (!controlIndex) {
  1084.                 returnValue = ENOTCONN;
  1085.                 break;
  1086.             }
  1087.         }
  1088.  
  1089.         switch(sockopt_name(sopt)) {
  1090.             case SO_FILTER_UPLOAD: {
  1091.                 #if DEBUG_IPK
  1092.                     printf("ik_setoption: received SO_FILTER_UPLOAD\n");
  1093.                 #endif
  1094.                 returnValue = sockopt_copyout(sopt, kft_filterTableD.bytes, kft_filterTableD.length);
  1095.                 if (returnValue != 0) break;
  1096.                 #if DEBUG_IPK
  1097.                     printf("ik_setoption: sooptcopyout OK %d\n",outBuf.length);
  1098.                 #endif
  1099.                 returnValue = EJUSTRETURN;
  1100.                 break;
  1101.             }
  1102.             case SO_FILTER_COUNT: {
  1103.                 #if DEBUG_IPK
  1104.                     printf("ik_setoption: received SO_FILTER_COUNT\n");
  1105.                 #endif
  1106.                 count = KFT_filterCount();
  1107.                 returnValue = sockopt_copyout(sopt, &count, sizeof(count));
  1108.                 if (returnValue != 0) break;
  1109.                 returnValue = EJUSTRETURN;
  1110.                 break;
  1111.             }
  1112.             case SO_TRIGGER_COUNT: {
  1113.                 #if DEBUG_IPK
  1114.                     printf("ik_setoption: received SO_TRIGGER_COUNT\n");
  1115.                 #endif
  1116.                 count = KFT_triggerCount();
  1117.                 returnValue = sockopt_copyout(sopt, &count, sizeof(count));
  1118.                 if (returnValue != 0) break;
  1119.                 returnValue = EJUSTRETURN;
  1120.                 break;
  1121.             }
  1122.             case SO_INTERFACE_COUNT: {
  1123.                 #if DEBUG_IPK
  1124.                     printf("ik_setoption: received SO_INTERFACE_COUNT\n");
  1125.                 #endif
  1126.                 count = ik_attachCount(controlIndex);
  1127.                 returnValue = sockopt_copyout(sopt, &count, sizeof(count));
  1128.                 if (returnValue != 0) break;
  1129.                 returnValue = EJUSTRETURN;
  1130.                 break;
  1131.             }
  1132. #ifdef IPNetRouter
  1133.             case SO_PORTMAP_COUNT: {
  1134.                 #if DEBUG_IPK
  1135.                     printf("ik_setoption: received SO_PORTMAP_COUNT\n");
  1136.                 #endif
  1137.                 count = KFT_portMapCount();
  1138.                 returnValue = sockopt_copyout(sopt, &count, sizeof(count));
  1139.                 if (returnValue != 0) break;
  1140.                 returnValue = EJUSTRETURN;
  1141.                 break;
  1142.             }
  1143. #endif
  1144.             default: {
  1145.                 #if DEBUG_IPK
  1146.                     printf("ik_getoption: default unrecognized sopt->sopt_name=%x pass it on\n", sockopt_name(sopt));
  1147.                 #endif
  1148.                 returnValue = 0;
  1149.                 break;
  1150.             }
  1151.         }    // end switch
  1152.     } while (FALSE);
  1153.     #if 0
  1154.         printf("ik_getoption returnValue: %d\n", returnValue);
  1155.     #endif    
  1156.     return returnValue;
  1157. }
  1158.  
  1159.  
  1160. static    errno_t
  1161. ik_listen(void *cookie, socket_t so)
  1162. {
  1163.     return 0;
  1164. }
  1165.                  
  1166.  
  1167. static    errno_t
  1168. ik_ioctl(void *cookie, socket_t so,
  1169.                     u_int32_t request, const char* argp)
  1170. {
  1171.     return 0;
  1172. }
  1173.  
  1174.  
  1175. #pragma mark -- Tiger protocol filter intercept functions
  1176. // ---------------------------------------------------------------------------------
  1177. //    Ñ ipk_ipf_input_func
  1178. // ---------------------------------------------------------------------------------
  1179. // Notice we are called to filter IP packets so we assume the mbuf contains a PKTHDR
  1180. static errno_t 
  1181. ipk_ipf_input_func(caddr_t cookie, mbuf_t *data, int hlen, u_int8_t protocol)
  1182. {
  1183.     int returnValue = 0;
  1184.     attach_t* myAttach;
  1185.     size_t len;
  1186.  
  1187.     // avoid duplicates
  1188.     if ( PROJECT_is_mtag(*data, TAG_IN) ) return 0;
  1189.     returnValue = PROJECT_mtag(*data, TAG_IN);
  1190.     if (returnValue != 0) return returnValue;    // if allocation failed, get out
  1191.     
  1192.     // get access to our attach instance
  1193.     myAttach = (attach_t*)cookie;
  1194.     
  1195.     // IPNetRouterX does not use protocol filter NKEs at this time
  1196. #if 0
  1197.     KFT_packetData_t packet;
  1198.     bzero(&packet, sizeof(packet));
  1199.     packet.ipOffset = 0;
  1200.     packet.direction = 1;
  1201.     packet.myAttach = myAttach;
  1202.     returnValue = KFT_filterPacket(&packet);
  1203. #endif
  1204.     
  1205.     // count receive traffic
  1206.     len = mbuf_pkthdr_len(*data);
  1207.     OSAddAtomic(len, (SInt32*)&myAttach->receiveCount);
  1208.     
  1209.     return returnValue;
  1210. }
  1211.  
  1212. static errno_t 
  1213. ipk_ipf_output_func(caddr_t cookie, mbuf_t *data, ipf_pktopts_t options)
  1214. {
  1215.     int returnValue = 0;
  1216.     attach_t* myAttach;
  1217.     size_t len;
  1218.  
  1219.     // avoid duplicates
  1220.     if ( PROJECT_is_mtag(*data, TAG_OUT) ) return 0;
  1221.     returnValue = PROJECT_mtag(*data, TAG_OUT);
  1222.     if (returnValue != 0) return returnValue;    // if allocation failed, get out
  1223.  
  1224.     // get access to our attach instance
  1225.     myAttach = (attach_t*)cookie;
  1226.     
  1227.     // Count whatever we get at this level.  Notice VPN might be counted twice.
  1228.     //if (protocol != IPPROTO_ICMP && protocol != IPPROTO_TCP &&  protocol != IPPROTO_TCP) return 0;
  1229.     
  1230.     // Notice we are called to filter IP packets so we assume the mbuf contains a PKTHDR
  1231.     //mbuf_flags_t flags = mbuf_flags(*data);
  1232.     //if (flags & MBUF_PKTHDR)
  1233.     
  1234.     // IPNetSentryX does not use protocol filter NKEs at this time
  1235. #if 0
  1236.     KFT_packetData_t packet;
  1237.     bzero(&packet, sizeof(packet));
  1238.     packet.ipOffset = 0;
  1239.     packet.direction = 0;
  1240.     packet.myAttach = myAttach;
  1241.     returnValue = KFT_filterPacket(&packet);
  1242. #endif
  1243.     // count receive traffic
  1244.     len = mbuf_pkthdr_len(*data);
  1245.     //myAttach->sendCount += len;
  1246.     OSAddAtomic(len, (SInt32*)&myAttach->sendCount);
  1247.     
  1248.     return returnValue;
  1249. }
  1250.  
  1251. static void 
  1252. ipk_ipf_detach_func(caddr_t cookie)
  1253. {
  1254.     //printf("ipk_ipf_detach_func: %x\n", *(ipfilter_t*)cookie);
  1255. }
  1256.  
  1257.  
  1258. #pragma mark -- Tiger interface filter intercept functions
  1259.  
  1260. static void ipk_iff_detached_func(
  1261.     void *cookie, 
  1262.     ifnet_t interface)
  1263. {
  1264. } 
  1265.  
  1266. static void ipk_iff_event_func(
  1267.     void *cookie, 
  1268.     ifnet_t interface, 
  1269.     protocol_family_t protocol, 
  1270.     const struct kev_msg *event_msg)
  1271. {
  1272.     // check for interface detaching event
  1273.     if (event_msg->event_code == KEV_DL_IF_DETACHING) {
  1274.         attach_t* myAttach;
  1275.         u_int8_t attachIndex;
  1276.         // get access to our attach instance
  1277.         myAttach = (attach_t*)cookie;
  1278.         attachIndex = myAttach->attachIndex;
  1279.         // make sure interface is detached
  1280.         if (PROJECT_attach[attachIndex].ifnet_ref) {
  1281.             PROJECT_lock();
  1282.             ik_detachInterface(attachIndex);
  1283.             PROJECT_unlock();
  1284.         }
  1285.     }
  1286. }
  1287.  
  1288. static errno_t ipk_iff_input_func(
  1289.     void *cookie, 
  1290.     ifnet_t interface, 
  1291.     protocol_family_t protocol, 
  1292.     mbuf_t *data, 
  1293.     char **frame_ptr)
  1294. {
  1295.     int returnValue = 0;
  1296.     attach_t* myAttach;
  1297.     int32_t len;
  1298.  
  1299.     // avoid duplicates
  1300.     if ( PROJECT_is_mtag(*data, TAG_IN) ) return 0;
  1301.     returnValue = PROJECT_mtag(*data, TAG_IN);
  1302.     if (returnValue != 0) return returnValue;    // if allocation failed, get out
  1303.  
  1304.      // get access to our attach instance
  1305.     myAttach = (attach_t*)cookie;
  1306.         
  1307.     // Notice we are called to filter IP packets so we assume the mbuf_t contains a PKTHDR
  1308.     //mbuf_flags_t flags = mbuf_flags(*data);
  1309.     //if (flags & MBUF_PKTHDR)
  1310.     
  1311.     // count receive traffic
  1312.     len = mbuf_pkthdr_len(*data);
  1313. //    myAttach->receiveCount += len;
  1314.     OSAddAtomic(len, (SInt32*)&myAttach->receiveCount);
  1315.  
  1316.     // IP filtering
  1317.     if (PROJECT_timerRefCount) {
  1318.         // mutex lock
  1319.         lck_mtx_lock(tnke_lock);
  1320.         
  1321.         KFT_packetData_t packet;
  1322.         bzero(&packet, sizeof(packet));
  1323.         // passed in
  1324.         packet.ifnet_ref = interface;
  1325.         packet.protocol = protocol;
  1326.         packet.mbuf_ptr = data;
  1327.         packet.frame_ptr = frame_ptr;
  1328.         packet.myAttach = myAttach;        // cookie
  1329.         // link layer info
  1330.         packet.ifType = ifnet_type(interface);
  1331.         packet.ifHeaderLen = ifnet_hdrlen(interface);
  1332.         // check frame header for IPv4
  1333.         if (packet.ifType == IFT_ETHER) {
  1334.             u_int16_t* dp16;
  1335.             if (*frame_ptr) {    // defensive
  1336.                 dp16 = (u_int16_t*)(*frame_ptr);
  1337.                 if (dp16[6] != 0x0800) packet.bridgeNonIP = 1;
  1338.             }
  1339.         }
  1340.         // packet  info
  1341.         packet.ipOffset = 0;
  1342.         packet.direction = 1;
  1343.         // pass to filter
  1344.         returnValue = KFT_filterPacket(&packet);
  1345.  
  1346.         // mutex unlock
  1347.         lck_mtx_unlock(tnke_lock);
  1348.     }
  1349.     
  1350.     return returnValue;
  1351. }
  1352.  
  1353. static errno_t ipk_iff_ioctl_func(
  1354.     void *cookie,
  1355.     ifnet_t interface,
  1356.     protocol_family_t protocol, 
  1357.     u_long ioctl_cmd,
  1358.     void* ioctl_arg)
  1359. {
  1360.     return EOPNOTSUPP;
  1361. }
  1362.  
  1363. static errno_t ipk_iff_output_func(
  1364.     void *cookie,
  1365.     ifnet_t interface,
  1366.     protocol_family_t protocol, 
  1367.     mbuf_t *data)
  1368. {
  1369.     int returnValue = 0;
  1370.     attach_t* myAttach;
  1371.     int32_t len;
  1372.  
  1373.     // avoid duplicates
  1374.     if ( PROJECT_is_mtag(*data, TAG_OUT) ) return 0;
  1375.     returnValue = PROJECT_mtag(*data, TAG_OUT);
  1376.     if (returnValue != 0) return returnValue;    // if allocation failed, get out
  1377.  
  1378.     // get access to our attach instance
  1379.     myAttach = (attach_t*)cookie;
  1380.     
  1381.     // Count whatever we get at this level.  Notice VPN might be counted twice.
  1382.     //if (protocol != IPPROTO_ICMP && protocol != IPPROTO_TCP &&  protocol != IPPROTO_TCP) return 0;
  1383.     
  1384.     // Notice we are called to filter IP packets so we assume the mbuf_t contains a PKTHDR
  1385.     //mbuf_flags_t flags = mbuf_flags(*data);
  1386.     //if (flags & MBUF_PKTHDR)
  1387.     
  1388.     // count receive traffic
  1389.     len = mbuf_pkthdr_len(*data) - ifnet_hdrlen(interface);
  1390. //    myAttach->sendCount += len;
  1391.     OSAddAtomic(len, (SInt32*)&myAttach->sendCount);
  1392.  
  1393.     // IP filtering
  1394.     if (PROJECT_timerRefCount) {
  1395.         // mutex lock
  1396.         lck_mtx_lock(tnke_lock);
  1397.         
  1398.         KFT_packetData_t packet;
  1399.         bzero(&packet, sizeof(packet));
  1400.         // passed in
  1401.         packet.ifnet_ref = interface;
  1402.         packet.protocol = protocol;
  1403.         packet.mbuf_ptr = data;
  1404.         packet.frame_ptr = 0;
  1405.         packet.myAttach = myAttach;
  1406.         // link layer info
  1407.         packet.ifType = ifnet_type(interface);
  1408.         packet.ifHeaderLen = ifnet_hdrlen(interface);
  1409.  
  1410.         // fix header to work around PPP bug
  1411.         if (packet.ifType == IFT_PPP) {
  1412.             // fix header to work around PPP bug
  1413.             //if ((m->m_data[headerLength-2] & 0xF0) == 0x40) headerLength -= 2;
  1414.             u_int8_t* dp = mbuf_data(*data);
  1415.             if ((dp[packet.ifHeaderLen-2] & 0xF0) == 0x40) packet.ifHeaderLen -= 2;
  1416.         }
  1417.         
  1418.         // check frame header for IP
  1419.         if (packet.ifType == IFT_ETHER) {
  1420.             u_int16_t* dp16;
  1421.             dp16 = (u_int16_t*)mbuf_data(*data);
  1422.             if (dp16[6] != 0x0800) packet.bridgeNonIP = 1;
  1423.         }
  1424.         // packet info
  1425.         packet.ipOffset = packet.ifHeaderLen;        // output packets preceeded by frame header
  1426.         packet.direction = 0;
  1427.         // pass to filter
  1428.         returnValue = KFT_filterPacket(&packet);
  1429.  
  1430.         // mutex unlock
  1431.         lck_mtx_unlock(tnke_lock);
  1432.     }
  1433.     
  1434.     return returnValue;
  1435. }
  1436.  
  1437.  
  1438. #pragma mark -- NKE support functions --
  1439. #pragma mark does mutex lock
  1440.  
  1441. // ---------------------------------------------------------------------------------
  1442. //    Ñ PROJECT_lock
  1443. // ---------------------------------------------------------------------------------
  1444. void PROJECT_lock()
  1445. {
  1446.     // lock to allow one thread at a time
  1447.     lck_mtx_lock(tnke_lock);
  1448. }
  1449. // ---------------------------------------------------------------------------------
  1450. //    Ñ PROJECT_unlock
  1451. // ---------------------------------------------------------------------------------
  1452. void PROJECT_unlock()
  1453. {
  1454.     // unlock
  1455.     lck_mtx_unlock(tnke_lock);
  1456. }
  1457.  
  1458. // ---------------------------------------------------------------------------------
  1459. //    Ñ ik_connect
  1460. // ---------------------------------------------------------------------------------
  1461. //    Register connection between controller socket and our NKE
  1462. //    Called via PF_NKE, ik_setoption (set_SO) and also soconnect (standard UDP)
  1463. static int ik_connect(socket_t cso)
  1464. {
  1465.     int returnValue = 0;
  1466.     int controlIndex;
  1467. #if DEBUG_IPK
  1468.             printf("ik_connect\n");
  1469. #endif
  1470.     // mutex lock
  1471.     lck_mtx_lock(tnke_lock);
  1472.  
  1473.     do {
  1474.         // check if this controller socket is already connected
  1475.         controlIndex = ik_controlIndexForSocket(cso);
  1476.         if (controlIndex) {    // found it
  1477.             returnValue = EISCONN;
  1478.             break;
  1479.         }
  1480.  
  1481.         // find slot for connection instance
  1482.         controlIndex = ik_emptyControlIndex();
  1483.         if (!controlIndex) {
  1484.             returnValue = EBUSY;
  1485.             break;        // all connection slots full
  1486.         }
  1487.         // register we have a connection
  1488.         PROJECT_control[controlIndex].ctl = cso;
  1489.         // we don't retain the socket since we want to be notified when it closes.
  1490.         returnValue = EJUSTRETURN;
  1491.     } while (FALSE);
  1492.  
  1493.     // mutex unlock
  1494.     lck_mtx_unlock(tnke_lock);
  1495.     
  1496.     return returnValue;
  1497. }
  1498.  
  1499.  
  1500. // ---------------------------------------------------------------------------------
  1501. //    Ñ ik_disconnect
  1502. // ---------------------------------------------------------------------------------
  1503. static void ik_disconnect(socket_t cso)
  1504. {
  1505.     int controlIndex;
  1506.  
  1507.     #if DEBUG_IPK
  1508.         printf("ik_disconnect\n");
  1509.     #endif
  1510.     // mutex lock
  1511.     lck_mtx_lock(tnke_lock);
  1512.     
  1513.     // check if this controller socket is connected and remove it
  1514.     controlIndex = ik_controlIndexForSocket(cso);
  1515.     if (controlIndex) {    // found it
  1516.         // remove reference to attach instance and clear control instance
  1517.         ik_detachController(controlIndex);
  1518.     }
  1519.     
  1520.     // mutex unlock
  1521.     lck_mtx_unlock(tnke_lock);
  1522. }
  1523.  
  1524. // ---------------------------------------------------------------------------------
  1525. //    Ñ ipk_timeout
  1526. // ---------------------------------------------------------------------------------
  1527. //    one second timer used for monitoring
  1528. //    reschedules itself to be called each second when timerRefCount > 0
  1529. static void ipk_timeout(void *cookie)
  1530. {
  1531.     // lock to allow one thread at a time
  1532.     lck_mtx_lock(tnke_lock);
  1533.  
  1534.     KFT_filterPeriodical();
  1535.     ipk_setTimer();
  1536.     // unlock
  1537.     lck_mtx_unlock(tnke_lock);
  1538. }
  1539.  
  1540. #pragma mark no mutex lock (caller must have it)
  1541.  
  1542. // ---------------------------------------------------------------------------------
  1543. //    Ñ ipk_setTimer
  1544. // ---------------------------------------------------------------------------------
  1545. //    reschedules timer to be called each second when timerRefCount > 0
  1546. static void ipk_setTimer()
  1547. {
  1548.     struct timespec ts;    
  1549.     ts.tv_sec = 1;        // one second interval
  1550.     ts.tv_nsec = 0;
  1551.     // reschedule ourself if anyone needs us
  1552.         // timeout(void (*func)(), void *cookie, int ticks);
  1553.     if (PROJECT_timerRefCount > 0) {
  1554.         ipk_timerPending = TRUE;
  1555.         bsd_timeout(ipk_timeout, (void *)0, &ts);
  1556.     }
  1557.     else {
  1558.         ipk_timerPending = FALSE;
  1559.         #if DEBUG_IPK
  1560.             printf("ipk_timeout: stop timer\n");
  1561.         #endif
  1562.     }    
  1563. }
  1564.  
  1565. // ---------------------------------------------------------------------------------
  1566. //    Ñ PROJECT_sendMessageToAll
  1567. // ---------------------------------------------------------------------------------
  1568. //     send message to each active controller
  1569. void PROJECT_sendMessageToAll(ipk_message_t *message)
  1570. {
  1571.     int i;
  1572.     for (i=1;i<=kMaxControl;i++) {
  1573.         if (PROJECT_control[i].ctl) {
  1574.             // increment NKE sends since last request so we don't
  1575.             // keep flooding input queue when no one is listening.
  1576.             PROJECT_control[i].nkeSends += 1;
  1577.             if (PROJECT_control[i].nkeSends < 250) {        // max messages allowed in 2.5 seconds
  1578.                 PROJECT_sendMessage(PROJECT_control[i].ctl, message);
  1579.             }
  1580.         }
  1581.     }
  1582. }
  1583.  
  1584. // ---------------------------------------------------------------------------------
  1585. //    Ñ PROJECT_sendMessage
  1586. // ---------------------------------------------------------------------------------
  1587. //     send message to controlling socket
  1588. //  assumes caller has mutex lock
  1589. void PROJECT_sendMessage(socket_t ctl, ipk_message_t *message)
  1590. {
  1591.     struct sockaddr from;
  1592.     mbuf_t mbuf;
  1593.     errno_t status;
  1594.     
  1595.     do {
  1596.         void* dp;            // pointer to actual mbuf data
  1597.         size_t size;
  1598.         if (!ctl) break;    // defensive
  1599.         
  1600.         // setup from address
  1601.         bzero(&from, 16);
  1602.         from.sa_len = 16;
  1603.         from.sa_family = PF_INET;
  1604.         
  1605.         // get mbuf with cluster to hold our message
  1606.         status = mbuf_getpacket(MBUF_DONTWAIT, &mbuf);
  1607.         if (status != 0) break;
  1608.         
  1609.         status = mbuf_settype(mbuf, MBUF_TYPE_DATA);
  1610.         
  1611.         // confirm we have enough space for message
  1612.         size = mbuf_maxlen(mbuf);
  1613.         if (message->length > size) {
  1614.             mbuf_freem(mbuf);
  1615.             printf("sendMessage: mbuf too small for message\n");
  1616.             break;
  1617.         }
  1618.         // copy data to cluster
  1619.         dp = mbuf_datastart(mbuf);
  1620.         bcopy(message, dp, message->length);
  1621.         // set data and length
  1622.         status = mbuf_setdata(mbuf, dp, message->length);
  1623.         if (status != 0) {
  1624.             mbuf_freem(mbuf);
  1625.             printf("mbuf_setData: failed %d\n",status);
  1626.             break;
  1627.         }
  1628.         
  1629.         // inject data to socket
  1630.         status = sock_inject_data_in(
  1631.             ctl,
  1632.             &from, 
  1633.             mbuf,
  1634.             NULL,
  1635.             sock_data_filt_flag_record);
  1636.             
  1637.         if (status != 0) {
  1638.             mbuf_freem(mbuf);
  1639.             printf("sock_inject_data_in: failed %d\n",status);
  1640.             break;
  1641.         }
  1642.  
  1643.     } while (FALSE);
  1644. }
  1645.  
  1646. // ---------------------------------------------------------------------------------
  1647. //    Ñ ik_attachCount
  1648. // ---------------------------------------------------------------------------------
  1649. // how many attachments does this controller reference
  1650. static int ik_attachCount(int controlIndex)
  1651. {
  1652.     int count, i;
  1653.     count = 0;
  1654.     // valid controlIndex?
  1655.     if ((controlIndex > 0) && (controlIndex <= kMaxControl)) {
  1656.         // for each attach instance
  1657.         for (i=1; i<=kMaxAttach; i++) {
  1658.             // does this controller reference it
  1659.             if (PROJECT_control[controlIndex].attachMap[i]) count += 1;
  1660.         }
  1661.     }
  1662.     return count;    
  1663. }
  1664.  
  1665. // ---------------------------------------------------------------------------------
  1666. //    Ñ ik_controlCount
  1667. // ---------------------------------------------------------------------------------
  1668. // how many controllers reference this attachment
  1669. static int ik_controlCount(int attachIndex)
  1670. {
  1671.     int count, i;
  1672.     count = 0;
  1673.     // valid attachIndex?
  1674.     if ((attachIndex > 0) && (attachIndex <= kMaxAttach)) {
  1675.         // for each control instance
  1676.         for (i=1; i<=kMaxControl; i++) {
  1677.             // does it reference this attach instance
  1678.             if (PROJECT_control[i].attachMap[attachIndex]) count += 1;
  1679.         }
  1680.     }
  1681.     return count;
  1682. }
  1683.  
  1684. // ---------------------------------------------------------------------------------
  1685. //    Ñ ik_controlIndexForSocket
  1686. // ---------------------------------------------------------------------------------
  1687. //    Find controller instance with corresponding socket if any and pass back it's index.
  1688. //    Returns 0 for not found
  1689. static int ik_controlIndexForSocket(socket_t so)
  1690. {
  1691.     int returnValue = 0;        // controller not connected ENOTCONN
  1692.     int i;
  1693.     
  1694.     for (i=1; i<=kMaxControl; i++) {
  1695.         if (PROJECT_control[i].ctl == so) {
  1696.             returnValue = i;
  1697.             break;
  1698.         }
  1699.     }
  1700.     return returnValue;
  1701. }
  1702.  
  1703.  
  1704. // ---------------------------------------------------------------------------------
  1705. //    Ñ ik_emptyControlIndex
  1706. // ---------------------------------------------------------------------------------
  1707. //    Find an empty controller instance (available slot)
  1708. //    Returns 0 for not found
  1709. static int ik_emptyControlIndex()
  1710. {
  1711.     int returnValue = 0;        // all slots in use EBUSY
  1712.     int i;
  1713.     
  1714.     for (i=1; i<=kMaxControl; i++) {
  1715.         if (PROJECT_control[i].ctl == 0) {
  1716.             returnValue = i;
  1717.             break;
  1718.         }
  1719.     }
  1720.     return returnValue;
  1721. }
  1722.  
  1723. // ---------------------------------------------------------------------------------
  1724. //    Ñ ik_attachIndexForName
  1725. // ---------------------------------------------------------------------------------
  1726. //    Find attach instance with corresponding bsdName.
  1727. //    Return 0 for not found.
  1728. static int ik_attachIndexForName(char *inName)
  1729. {
  1730.     int returnValue = 0;    // no such entry ENOENT
  1731.     int i;
  1732.     int len;
  1733.     
  1734.     len = strlen(inName);
  1735.     for (i=1; i<=kMaxAttach; i++) {
  1736.         if ( memcmp(inName, &PROJECT_attach[i].kftInterfaceEntry.bsdName[0], len) == 0 ) {
  1737.             returnValue = i;
  1738.             break;
  1739.         }
  1740.     }
  1741.     return returnValue;
  1742. }
  1743.  
  1744. // ---------------------------------------------------------------------------------
  1745. //    Ñ ik_emptyAttachIndex
  1746. // ---------------------------------------------------------------------------------
  1747. //    Find an empty attach instance (available slot)
  1748. //    Return 0 for not found
  1749. static int ik_emptyAttachIndex()
  1750. {
  1751.     int returnValue = 0;    // all slots in use EBUSY
  1752.     int i;
  1753.     
  1754.     for (i=1; i<=kMaxAttach; i++) {
  1755.         if ((PROJECT_attach[i].ipFilterRef == 0) && (PROJECT_attach[i].ifFilterRef == 0)) {
  1756.             returnValue = i;
  1757.             break;
  1758.         }
  1759.     }
  1760.     return returnValue;
  1761. }
  1762.  
  1763. // ---------------------------------------------------------------------------------
  1764. //    Ñ ik_detachController
  1765. // ---------------------------------------------------------------------------------
  1766. //    detach controller and remove any interface attachments
  1767. //    that are no longer referenced.  Finally, clear the control instance.
  1768. //
  1769. //    return 0 for success or unix error code
  1770. static int ik_detachController(int controlIndex)
  1771. {
  1772.     int returnValue=0;
  1773.     int attachIndex;
  1774.     int result;
  1775.     do {
  1776.         if (!controlIndex) break;    // no control instance, we're done
  1777.         // make sure delay table is empty before detaching from any interfaces
  1778.         KFT_delayAge(0);                
  1779.         // if controller was monitoring, turn it off
  1780.         // - user might quit app without stopping or closing monitor window
  1781.         if (PROJECT_control[controlIndex].monitorOn) {
  1782.             PROJECT_control[controlIndex].monitorOn = 0;
  1783.             // bump timer ref count
  1784.             //PROJECT_timerRefCount -= 1;
  1785.             //if (PROJECT_timerRefCount < 0) PROJECT_timerRefCount = 0;
  1786.             result = OSAddAtomic(-1, (SInt32*)&PROJECT_timerRefCount);
  1787.             if (result <= 0) PROJECT_timerRefCount = 0;    // defensive
  1788.         }
  1789.         // get corresponding attach instances
  1790.         for (attachIndex=1;attachIndex<=kMaxAttach;attachIndex++) {
  1791.             if (PROJECT_control[controlIndex].attachMap[attachIndex]) {
  1792.                 // remove our reference to attach instance
  1793.                 PROJECT_control[controlIndex].attachMap[attachIndex] = 0;            
  1794.                 // are there any more references?
  1795.                 if (ik_controlCount(attachIndex) == 0) {
  1796.                     // no more references to this attach instance
  1797.                     // detach our NKE from this interface and clear instance
  1798.                     if (PROJECT_attach[attachIndex].ifFilterRef || PROJECT_attach[attachIndex].ipFilterRef) {
  1799.                         ik_detachInterface(attachIndex);
  1800.                     }
  1801.                 }
  1802.             }    // end found attach instance
  1803.         }    // end for each attach instance
  1804.         // clear control instance
  1805.         bzero(&PROJECT_control[controlIndex], sizeof(control_t));
  1806.     } while (FALSE);
  1807.     return returnValue;
  1808. }
  1809.  
  1810.  
  1811. // ---------------------------------------------------------------------------------
  1812. //    Ñ ik_detachInterface
  1813. // ---------------------------------------------------------------------------------
  1814. //    detach interface and clear the attach instance
  1815. //    return 0 for success or unix error code
  1816. static int ik_detachInterface(int attachIndex)
  1817. {
  1818.     int returnValue=0;
  1819.     errno_t status;
  1820.     int i;
  1821.     do {
  1822.         if ((attachIndex == 0) || (attachIndex > kMaxAttach)) break;    // no attach instance, we're done
  1823.         // for each control instance
  1824.         for (i=1; i<=kMaxControl; i++) {
  1825.             // dis-associate with this attach instance
  1826.             PROJECT_control[i].attachMap[attachIndex] = 0;
  1827.         }
  1828.         // detach our NKE from this interface and clear instance
  1829.             // ifnet_ref
  1830.             // release and set to zero before dlil_detach_filter which calls ipk_ipf_detach_func
  1831.         if (PROJECT_attach[attachIndex].ifnet_ref) ifnet_release(PROJECT_attach[attachIndex].ifnet_ref);
  1832.         PROJECT_attach[attachIndex].ifnet_ref = 0;
  1833.             // ifFilterRef
  1834.         if (PROJECT_attach[attachIndex].ifFilterRef) iflt_detach(PROJECT_attach[attachIndex].ifFilterRef);
  1835.             // ipFilterRef
  1836.         if (PROJECT_attach[attachIndex].ipFilterRef) {
  1837.             status = ipf_remove(PROJECT_attach[attachIndex].ipFilterRef);
  1838.             if (status) {
  1839.                 printf("ik_detachInterface: ipf_remove failed %d\n", status);
  1840.                 returnValue = KERN_FAILURE;
  1841.             }
  1842.         }
  1843.         bzero(&PROJECT_attach[attachIndex], sizeof(attach_t));
  1844.     } while (0);
  1845.     return returnValue;
  1846. }
  1847.  
  1848. // ---------------------------------------------------------------------------------
  1849. //    Ñ PROJECT_modifyReadyPacket
  1850. // ---------------------------------------------------------------------------------
  1851. // Tiger: prepare packet to be modified by finalizing and setting appropriate mbuf flags, return 0
  1852. // Panther: return 1 if outbound hardware TCP checksum is enabled so calculation should be skipped
  1853. // (no easy way to "finalize" in Panther)
  1854. int PROJECT_modifyReadyPacket(KFT_packetData_t* packet)
  1855. {
  1856.     int returnValue = 0;
  1857.     mbuf_t mbuf_ref;
  1858. #if TIGER
  1859.     if (packet->modifyReady == 0) {
  1860.         mbuf_ref = *(packet->mbuf_ptr);
  1861.         if (packet->direction == kDirectionInbound) {
  1862.             mbuf_inbound_modified(mbuf_ref);
  1863.         }
  1864.         else {
  1865.             mbuf_outbound_finalize(mbuf_ref, AF_INET, packet->ipOffset);
  1866.             #if 1
  1867.                 mbuf_csum_request_flags_t request;
  1868.                 u_int32_t value;
  1869.                 mbuf_get_csum_requested(mbuf_ref, &request, &value);
  1870.                 // work around bug in 10.4.2
  1871.                 if (request & 0x1000) returnValue = 1;
  1872.                 if (request & MBUF_CSUM_REQ_TCP) returnValue = 1;
  1873.                 //KFT_logText("csum_requested ", &request);
  1874.             #endif
  1875.         }
  1876.         // remember what we did
  1877.         packet->modifyReady = 1;
  1878.     }
  1879. #else
  1880.     mbuf_ref = *(packet->mbuf_ptr);
  1881.     if (packet->direction == kDirectionInbound) {
  1882.         // invalidate HW generated checksum flags
  1883.         mbuf_ref->m_pkthdr.csum_data = 0;
  1884.         mbuf_ref->m_pkthdr.csum_flags = 0;
  1885.         //if ((mbuf_ref->m_pkthdr.csum_flags & CSUM_TCP_SUM16) &&
  1886.         //    (mbuf_ref->m_pkthdr.csum_flags & CSUM_DATA_VALID)) returnValue = 1;
  1887.     }
  1888.     else {
  1889.         // Notice for outgoing packets the tcp checksum may not include the TCP header yet
  1890.         if (mbuf_ref->m_pkthdr.csum_flags & CSUM_TCP_SUM16) returnValue = 1;
  1891.     }
  1892. #endif
  1893.     return returnValue;
  1894. }
  1895.  
  1896. // ---------------------------------------------------------------------------------
  1897. //    Ñ PROJECT_mtag
  1898. // ---------------------------------------------------------------------------------
  1899. // Tag this packet with "tag_value" so we'll know if we have seen it.
  1900. // tag_value will normally be either TAG_IN or TAG_OUT.
  1901. //
  1902. // Notice if an mbuf is re-used to send a response such as an echo request (ping) that
  1903. // is converted to an echo reply, or simply IP Forwarded back out another interface,
  1904. // you may want to recognize the redirected mbuf as a new packet.
  1905. // Thus we distinguish TAG_IN from TAG_OUT and intentionally replace the
  1906. // previous tag value rather than combining.  If we re-direct a packet, we need to
  1907. // re-tag it accordingly. The code below checks for an existing tag and resets the value.
  1908. //
  1909. // Finally, an mbuf tag is effectively another mbuf that travels with the packet.
  1910. // Allocating an mbuf tag can fail in which case we return the corresponding error code.
  1911. // Notice it is the callers responsibility to free the original packet to avoid looping
  1912. // or a recursive lock attempt (kernel panic) if a packet without the correct
  1913. // tag is re-injected and processed again.
  1914. //
  1915. errno_t PROJECT_mtag(mbuf_t mbuf_ref, int tag_value)
  1916. {
  1917.     errno_t status;
  1918.     int *tag_ref;
  1919.     size_t len;
  1920.     // look for existing tag
  1921.     status = mbuf_tag_find(mbuf_ref, gidtag, MY_TAG_TYPE, &len, (void*)&tag_ref);
  1922.     // allocate tag if needed
  1923.     if (status != 0) {
  1924.         status = mbuf_tag_allocate(mbuf_ref, gidtag, MY_TAG_TYPE, sizeof(*tag_ref), MBUF_DONTWAIT, (void**)&tag_ref);
  1925.         if (status == 0) *tag_ref = 0;
  1926.     }
  1927.     //if (status == 0) *tag_ref = tag_value;
  1928.     if (status == 0) {
  1929.         if (tag_value < 3) *tag_ref &= ~3;    // clear previous TAG_IN or TAG_OUT
  1930.         *tag_ref |= tag_value;
  1931.     }
  1932.     return status;
  1933. }
  1934.  
  1935. // ---------------------------------------------------------------------------------
  1936. //    Ñ PROJECT_is_mtag
  1937. // ---------------------------------------------------------------------------------
  1938. // Return 1 if packet is tagged with "tag_value", otherwise 0
  1939. int PROJECT_is_mtag(mbuf_t mbuf_ref, int tag_value)
  1940. {
  1941.     int returnValue = 0;
  1942.     errno_t status;
  1943.     int *tag_ref;
  1944.     size_t len;
  1945.     // Check whether we have seen this packet before.
  1946.     status = mbuf_tag_find(mbuf_ref, gidtag, MY_TAG_TYPE, &len, (void**)&tag_ref);
  1947.     if ((status == 0) && (*tag_ref & tag_value)) returnValue = 1;
  1948.     return returnValue;
  1949. }
  1950.  
  1951.