""" This module manages and invokes typed commands. """ import inspect import types import io import typing import shlex import textwrap import functools import sys from mitmproxy import exceptions import mitmproxy.types def verify_arg_signature(f: typing.Callable, args: list, kwargs: dict) -> None: sig = inspect.signature(f) try: sig.bind(*args, **kwargs) except TypeError as v: raise exceptions.CommandError("command argument mismatch: %s" % v.args[0]) def lexer(s): # mypy mis-identifies shlex.shlex as abstract lex = shlex.shlex(s, posix=True) # type: ignore lex.wordchars += "." lex.whitespace_split = True lex.commenters = '' return lex def typename(t: type) -> str: """ Translates a type to an explanatory string. """ to = mitmproxy.types.CommandTypes.get(t, None) if not to: raise NotImplementedError(t) return to.display class Command: def __init__(self, manager, path, func) -> None: self.path = path self.manager = manager self.func = func sig = inspect.signature(self.func) self.help = None if func.__doc__: txt = func.__doc__.strip() self.help = "\n".join(textwrap.wrap(txt)) self.has_positional = False for i in sig.parameters.values(): # This is the kind for *args parameters if i.kind == i.VAR_POSITIONAL: self.has_positional = True self.paramtypes = [v.annotation for v in sig.parameters.values()] self.returntype = sig.return_annotation def paramnames(self) -> typing.Sequence[str]: v = [typename(i) for i in self.paramtypes] if self.has_positional: v[-1] = "*" + v[-1] return v def retname(self) -> str: return typename(self.returntype) if self.returntype else "" def signature_help(self) -> str: params = " ".join(self.paramnames()) ret = self.retname() if ret: ret = " -> " + ret return "%s %s%s" % (self.path, params, ret) def prepare_args(self, args: typing.Sequence[str]) -> typing.List[typing.Any]: verify_arg_signature(self.func, list(args), {}) remainder: typing.Sequence[str] = [] if self.has_positional: remainder = args[len(self.paramtypes) - 1:] args = args[:len(self.paramtypes) - 1] pargs = [] for arg, paramtype in zip(args, self.paramtypes): pargs.append(parsearg(self.manager, arg, paramtype)) pargs.extend(remainder) return pargs def call(self, args: typing.Sequence[str]) -> typing.Any: """ Call the command with a list of arguments. At this point, all arguments are strings. """ ret = self.func(*self.prepare_args(args)) if ret is None and self.returntype is None: return typ = mitmproxy.types.CommandTypes.get(self.returntype) if not typ.is_valid(self.manager, typ, ret): raise exceptions.CommandError( "%s returned unexpected data - expected %s" % ( self.path, typ.display ) ) return ret ParseResult = typing.NamedTuple( "ParseResult", [ ("value", str), ("type", typing.Type), ("valid", bool), ], ) class CommandManager(mitmproxy.types._CommandBase): def __init__(self, master): self.master = master self.commands: typing.Dict[str, Command] = {} def collect_commands(self, addon): for i in dir(addon): if not i.startswith("__"): o = getattr(addon, i) try: is_command = hasattr(o, "command_path") except Exception: pass # hasattr may raise if o implements __getattr__. else: if is_command: self.add(o.command_path, o) def add(self, path: str, func: typing.Callable): self.commands[path] = Command(self, path, func) def parse_partial( self, cmdstr: str ) -> typing.Tuple[typing.Sequence[ParseResult], typing.Sequence[str]]: """ Parse a possibly partial command. Return a sequence of ParseResults and a sequence of remainder type help items. """ buf = io.StringIO(cmdstr) parts: typing.List[str] = [] lex = lexer(buf) while 1: remainder = cmdstr[buf.tell():] try: t = lex.get_token() except ValueError: parts.append(remainder) break if not t: break parts.append(t) if not parts: parts = [""] elif cmdstr.endswith(" "): parts.append("") parse: typing.List[ParseResult] = [] params: typing.List[type] = [] typ: typing.Type = None for i in range(len(parts)): if i == 0: typ = mitmproxy.types.Cmd if parts[i] in self.commands: params.extend(self.commands[parts[i]].paramtypes) elif params: typ = params.pop(0) if typ == mitmproxy.types.Cmd and params and params[0] == mitmproxy.types.Arg: if
#
# Copyright (C) 2006-2008 OpenWrt.org
#
# This is free software, licensed under the GNU General Public License v2.
# See /LICENSE for more information.
#

WIRELESS_MENU:=Wireless Drivers

define KernelPackage/net-prism54
  SUBMENU:=$(WIRELESS_MENU)
  TITLE:=Intersil Prism54 support
  DEPENDS:=@PCI_SUPPORT +@DRIVER_WEXT_SUPPORT +prism54-firmware
  KCONFIG:=CONFIG_PRISM54
  FILES:= \
	$(LINUX_DIR)/drivers/net/wireless/intersil/prism54/prism54.ko
  AUTOLOAD:=$(call AutoProbe,prism54)
endef

define KernelPackage/net-prism54/description
 Kernel modules for Intersil Prism54 support
endef

$(eval $(call KernelPackage,net-prism54))


define KernelPackage/net-rtl8192su
  SUBMENU:=$(WIRELESS_MENU)
  TITLE:=RTL8192SU support (staging)
  DEPENDS:=@USB_SUPPORT +@DRIVER_WEXT_SUPPORT +kmod-usb-core +rtl8192su-firmware
  KCONFIG:=\
	CONFIG_STAGING=y \
	CONFIG_R8712U
  FILES:=$(LINUX_DIR)/drivers/staging/rtl8712/r8712u.ko
  AUTOLOAD:=$(call AutoProbe,r8712u)
endef

define KernelPackage/net-rtl8192su/description
 Kernel modules for RealTek RTL8712 and RTL81XXSU fullmac support.
endef

$(eval $(call KernelPackage,net-rtl8192su))
generated by cgit v1.2.3 (git 2.25.1) at 2026-02-12 16:27:04 +0000