1/* 2 * Copyright 2003-2005, Haiku Inc. 3 * Distributed under the terms of the MIT License. 4 */ 5 6#ifndef _PPP_CONTROL__H 7#define _PPP_CONTROL__H 8 9#include <Drivers.h> 10#include <driver_settings.h> 11#include <PPPDefs.h> 12 13 14#define IF_NAMESIZE 32 15 // copied from if.h 16 17struct control_net_module_args { 18 char ifr_name[IF_NAMESIZE]; 19 const char* name; 20 uint32 op; 21 void* data; 22 size_t length; 23// union { 24// struct sockaddr ifr_addr; 25// struct sockaddr ifr_dstaddr; 26// struct sockaddr ifr_broadaddr; 27// struct sockaddr ifr_mask; 28// struct ifreq_stats ifr_stats; 29// struct route_entry ifr_route; 30// int ifr_flags; 31// int ifr_index; 32// int ifr_metric; 33// int ifr_mtu; 34// int ifr_media; 35// int ifr_type; 36// int ifr_reqcap; 37// int ifr_count; 38// uint8_t* ifr_data; 39// }; 40}; 41 // copied from libppp 42 43 44enum { 45 // Paranoia mode: be far away of B_DEVICE_OP_CODES_END opcodes!!! 46 // You never know what another device driver ioctl() will do 47 // if think our NET_STACK_* is in fact his DO_RISKY_BUSINESS opcode, or whatever... 48 NET_IOCTL_BASE = 0xbe230000, 49 NET_STACK_IOCTL_BASE = NET_IOCTL_BASE + 0x200 50}; 51 52enum { 53 NET_STACK_SOCKET = NET_STACK_IOCTL_BASE, // socket_args * 54 NET_STACK_BIND, // sockaddr_args * 55 NET_STACK_RECVFROM, // struct msghdr * 56 NET_STACK_RECV, // transfer_args * 57 NET_STACK_SENDTO, // struct msghdr * 58 NET_STACK_SEND, // transfer_args * 59 NET_STACK_LISTEN, // int_args * (value = backlog) 60 NET_STACK_ACCEPT, // sockaddr_args * 61 NET_STACK_CONNECT, // sockaddr_args * 62 NET_STACK_SHUTDOWN, // int_args * (value = how) 63 NET_STACK_GETSOCKOPT, // sockopt_args * 64 NET_STACK_SETSOCKOPT, // sockopt_args * 65 NET_STACK_GETSOCKNAME, // sockaddr_args * 66 NET_STACK_GETPEERNAME, // sockaddr_args * 67 68 NET_STACK_SYSCTL, // sysctl_args * 69 NET_STACK_SELECT, // select_args * 70 NET_STACK_DESELECT, // select_args * 71 72 NET_STACK_GET_COOKIE, // void ** 73 74 NET_STACK_STOP, 75 76 NET_STACK_NOTIFY_SOCKET_EVENT, // notify_socket_event_args * (userland stack only) 77 78 NET_STACK_CONTROL_NET_MODULE, 79 80 NET_STACK_IOCTL_MAX 81}; 82 83 84// various constants 85#define PPP_HANDLER_NAME_LENGTH_LIMIT 63 86 // if the name is longer than this value it will be truncated to fit the structure 87 88// starting values and other values for control ops 89#define PPP_RESERVE_OPS_COUNT 0xFFFF 90#define PPP_OPS_START B_DEVICE_OP_CODES_END + 1 91#define PPP_INTERFACE_OPS_START PPP_OPS_START + PPP_RESERVE_OPS_COUNT 92#define PPP_DEVICE_OPS_START PPP_OPS_START + 2 * PPP_RESERVE_OPS_COUNT 93#define PPP_PROTOCOL_OPS_START PPP_OPS_START + 3 * PPP_RESERVE_OPS_COUNT 94#define PPP_OPTION_HANDLER_OPS_START PPP_OPS_START + 5 * PPP_RESERVE_OPS_COUNT 95#define PPP_LCP_EXTENSION_OPS_START PPP_OPS_START + 6 * PPP_RESERVE_OPS_COUNT 96#define PPP_COMMON_OPS_START PPP_OPS_START + 10 * PPP_RESERVE_OPS_COUNT 97#define PPP_USER_OPS_START PPP_OPS_START + 32 * PPP_RESERVE_OPS_COUNT 98 99 100//! These values should be used for ppp_control_info::op. 101enum ppp_control_ops { 102 // ----------------------------------------------------- 103 // PPPManager (the PPP interface module) 104 PPPC_CONTROL_MODULE = PPP_OPS_START, 105 PPPC_CREATE_INTERFACE, 106 PPPC_CREATE_INTERFACE_WITH_NAME, 107 PPPC_DELETE_INTERFACE, 108 PPPC_BRING_INTERFACE_UP, 109 PPPC_BRING_INTERFACE_DOWN, 110 PPPC_CONTROL_INTERFACE, 111 PPPC_GET_INTERFACES, 112 PPPC_COUNT_INTERFACES, 113 PPPC_FIND_INTERFACE_WITH_SETTINGS, 114 // ----------------------------------------------------- 115 116 // ----------------------------------------------------- 117 // KPPPInterface 118 PPPC_GET_INTERFACE_INFO = PPP_INTERFACE_OPS_START, 119 PPPC_SET_USERNAME, 120 PPPC_SET_PASSWORD, 121 PPPC_SET_ASK_BEFORE_CONNECTING, 122 // ppp_up uses this in order to finalize a connection request 123 PPPC_SET_MRU, 124 PPPC_SET_CONNECT_ON_DEMAND, 125 PPPC_SET_AUTO_RECONNECT, 126 PPPC_HAS_INTERFACE_SETTINGS, 127 PPPC_GET_STATISTICS, 128 129 // handler access 130 PPPC_CONTROL_DEVICE = PPP_INTERFACE_OPS_START + 0xFF, 131 PPPC_CONTROL_PROTOCOL, 132 PPPC_CONTROL_OPTION_HANDLER, 133 PPPC_CONTROL_LCP_EXTENSION, 134 PPPC_CONTROL_CHILD, 135 // ----------------------------------------------------- 136 137 // ----------------------------------------------------- 138 // KPPPDevice 139 PPPC_GET_DEVICE_INFO = PPP_DEVICE_OPS_START, 140 // ----------------------------------------------------- 141 142 // ----------------------------------------------------- 143 // KPPPProtocol 144 PPPC_GET_PROTOCOL_INFO = PPP_PROTOCOL_OPS_START, 145 // ----------------------------------------------------- 146 147 // ----------------------------------------------------- 148 // Common/mixed ops 149 PPPC_ENABLE, 150 PPPC_GET_SIMPLE_HANDLER_INFO, 151 // KPPPOptionHandler and KPPPLCPExtension 152 153 // these two control ops use the ppp_report_request structure 154 PPPC_ENABLE_REPORTS, 155 PPPC_DISABLE_REPORTS, 156 // flags are not used for this control op 157 // ----------------------------------------------------- 158 159 PPP_CONTROL_OPS_END = B_DEVICE_OP_CODES_END + 0xFFFF 160}; 161 162 163//! Basic structure used for creating and searching PPP interfaces. 164typedef struct ppp_interface_description_info { 165 //! Different values for describing an interface. 166 union { 167 const driver_settings *settings; 168 //!< Interface settings. 169 const char *name; 170 //!< Name of interface description file. 171 } u; 172 ppp_interface_id interface; 173 //!< The id of the found/created interface. 174} ppp_interface_description_info; 175 176 177//! Used to get all interface ids from the PPP interface manager. 178typedef struct ppp_get_interfaces_info { 179 ppp_interface_id *interfaces; 180 //!< The interface ids will be written to this pointer's target. 181 int32 count; 182 //!< The \a interfaces field has enough space for \a count entries. 183 ppp_interface_filter filter; 184 //!< Only interfaces that match this filter will be returned 185 int32 resultCount; 186 //!< The number of entries that the \a interfaces field contains. 187} ppp_get_interfaces_info; 188 189 190//! With this structure you can refer to some handler/interface. 191typedef struct ppp_control_info { 192 uint32 index; 193 //!< Index/id of interface/protocol/etc. 194 uint32 op; 195 //!< The Control()/ioctl() opcode. This can be any value from ppp_control_ops. 196 void *data; 197 //!< Additional data may be specified here. 198 size_t length; 199 //!< The length should always be set. 200} ppp_control_info; 201 202 203// ----------------------------------------------------------- 204// structures for storing information about interface/handlers 205// use the xxx_info_t structures when allocating memory (they 206// reserve memory for future implementations) 207// ----------------------------------------------------------- 208#define _PPP_INFO_T_SIZE_ 256 209 210//! Structure used by \c PPPC_GET_INTERFACE_INFO. 211typedef struct ppp_interface_info { 212 char name[PPP_HANDLER_NAME_LENGTH_LIMIT + 1]; 213 int32 if_unit; 214 // negative if not registered 215 216 ppp_mode mode; 217 ppp_state state; 218 ppp_phase phase; 219 ppp_authentication_status localAuthenticationStatus, peerAuthenticationStatus; 220 ppp_pfc_state localPFCState, peerPFCState; 221 uint8 pfcOptions; 222 223 uint32 protocolsCount, optionHandlersCount, LCPExtensionsCount, childrenCount; 224 uint32 MRU, interfaceMTU; 225 226 uint32 connectAttempt, connectRetriesLimit; 227 uint32 connectRetryDelay, reconnectDelay; 228 bigtime_t connectedSince; 229 // undefined if disconnected 230 uint32 idleSince, disconnectAfterIdleSince; 231 232 bool doesConnectOnDemand, doesAutoReconnect, askBeforeConnecting, hasDevice; 233 bool isMultilink, hasParent; 234} ppp_interface_info; 235/*! \brief You \e must use this encapsulator instead of \c ppp_interface_info! 236 237 This structure guarantees backwards compatibility. 238*/ 239typedef struct ppp_interface_info_t { 240 ppp_interface_info info; 241 uint8 _reserved_[_PPP_INFO_T_SIZE_ - sizeof(ppp_interface_info)]; 242} ppp_interface_info_t; 243 244 245//! Structure used by \c PPPC_GET_STATISTICS. 246typedef struct ppp_statistics { 247 int64 bytesReceived, packetsReceived; 248 int64 bytesSent, packetsSent; 249 250 // TODO: currently unused 251 int64 errorBytesReceived, errorPacketsReceived; 252 253 // TODO: add compression statistics? 254 int8 _reserved_[80]; 255} ppp_statistics; 256 257//! Structure used by \c PPPC_GET_DEVICE_INFO. 258typedef struct ppp_device_info { 259 char name[PPP_HANDLER_NAME_LENGTH_LIMIT + 1]; 260 261 uint32 MTU; 262 uint32 inputTransferRate, outputTransferRate, outputBytesCount; 263 bool isUp; 264} ppp_device_info; 265/*! \brief You \e must use this encapsulator instead of \c ppp_device_info! 266 267 This structure guarantees backwards compatibility. 268*/ 269typedef struct ppp_device_info_t { 270 ppp_device_info info; 271 uint8 _reserved_[_PPP_INFO_T_SIZE_ - sizeof(ppp_device_info)]; 272} ppp_device_info_t; 273 274 275//! Structure used by \c PPPC_GET_PROTOCOL_INFO. 276typedef struct ppp_protocol_info { 277 char name[PPP_HANDLER_NAME_LENGTH_LIMIT + 1]; 278 char type[PPP_HANDLER_NAME_LENGTH_LIMIT + 1]; 279 280 ppp_phase activationPhase; 281 int32 addressFamily, flags; 282 ppp_side side; 283 ppp_level level; 284 uint32 overhead; 285 286 ppp_phase connectionPhase; 287 // there are four possible states: 288 // PPP_ESTABLISHED_PHASE - IsUp() == true 289 // PPP_DOWN_PHASE - IsDown() == true 290 // PPP_ESTABLISHMENT_PHASE - IsGoingUp() == true 291 // PPP_TERMINATION_PHASE - IsGoingDown() == true 292 293 uint16 protocolNumber; 294 bool isEnabled; 295 bool isUpRequested; 296} ppp_protocol_info; 297/*! \brief You \e must use this encapsulator instead of \c ppp_protocol_info! 298 299 This structure guarantees backwards compatibility. 300*/ 301typedef struct ppp_protocol_info_t { 302 ppp_protocol_info info; 303 uint8 _reserved_[_PPP_INFO_T_SIZE_ - sizeof(ppp_protocol_info)]; 304} ppp_protocol_info_t; 305 306 307//! Structure used by \c PPPC_GET_SIMPLE_HANDLER_INFO. 308typedef struct ppp_simple_handler_info { 309 char name[PPP_HANDLER_NAME_LENGTH_LIMIT + 1]; 310 311 bool isEnabled; 312 313 uint8 code; 314 // only KPPPLCPExtension 315} ppp_simple_handler_info; 316/*! \brief You \e must use this encapsulator instead of \c ppp_simple_handler_info! 317 318 This structure guarantees backwards compatibility. 319*/ 320typedef struct ppp_simple_handler_info_t { 321 ppp_simple_handler_info info; 322 uint8 _reserved_[_PPP_INFO_T_SIZE_ - sizeof(ppp_simple_handler_info)]; 323} ppp_simple_handler_info_t; 324 325 326#endif 327