ida_rename_multi_functions

Instructions

Implementation Reference

• src/mcp_server_ida/server.py:62-64 (schema)

  Pydantic schema/model for validating the tool input: list of old_name to new_name pairs.

  class RenameMultiFunctions(BaseModel):
      rename_pairs_old2new: List[Dict[str, str]]

• src/mcp_server_ida/server.py:983-987 (registration)

  MCP tool registration in list_tools() with name, description, and input schema.

  Tool(
      name=IDATools.RENAME_MULTI_FUNCTIONS,
      description="Rename multiple functions at once in the IDA database",
      inputSchema=RenameMultiFunctions.schema(), 
  ),

• src/mcp_server_ida/server.py:1133-1141 (handler)

  MCP server tool handler in call_tool(): calls ida_functions.rename_multi_functions() and returns result as text.

  case IDATools.RENAME_MULTI_FUNCTIONS:
      result: str = ida_functions.rename_multi_functions(
          arguments["rename_pairs_old2new"]
      )
      return [TextContent(
          type="text",
          text=result
      )]

• src/mcp_server_ida/server.py:630-656 (handler)

  Proxy handler in IDAProFunctions: sends 'rename_multi_functions' request to IDA plugin and formats response.

  def rename_multi_functions(self, rename_pairs_old2new: List[Dict[str, str]]) -> str:
      """Rename multiple functions at once"""
      try:
          response: Dict[str, Any] = self.communicator.send_request(
              "rename_multi_functions", 
              {"rename_pairs_old2new": rename_pairs_old2new}
          )
          
          if "error" in response:
              return f"Error renaming multiple functions: {response['error']}"
          
          success_count: int = response.get("success_count", 0)
          failed_pairs: List[Dict[str, str]] = response.get("failed_pairs", [])
          
          result_parts: List[str] = [
              f"Successfully renamed {success_count} functions"
          ]
          
          if failed_pairs:
              result_parts.append("\nFailed renamings:")
              for pair in failed_pairs:
                  result_parts.append(f"- {pair['old_name']} → {pair['new_name']}: {pair.get('error', 'Unknown error')}")
          
          return "\n".join(result_parts)
      except Exception as e:
          self.logger.error(f"Error renaming multiple functions: {str(e)}", exc_info=True)
          return f"Error renaming multiple functions: {str(e)}"

• plugin/ida_mcp_server_plugin/ida_mcp_core.py:628-667 (handler)

  Core implementation: loops over rename pairs, calls single _rename_function_internal for each, reports success/fail counts.

  @idawrite
  def rename_multi_functions(self, rename_pairs_old2new: List[Dict[str, str]]) -> Dict[str, Any]:
      """Rename multiple functions at once"""
      try:
          success_count: int = 0
          failed_pairs: List[Dict[str, str]] = []
  
          for pair in rename_pairs_old2new:
              old_name = next(iter(pair.keys()))
              new_name = pair[old_name]
              
              # Call existing rename_function_internal for each pair
              result = self._rename_function_internal(old_name, new_name)
              
              if result.get("success", False):
                  success_count += 1
              else:
                  failed_pairs.append({
                      "old_name": old_name,
                      "new_name": new_name,
                      "error": result.get("message", "Unknown error")
                  })
  
          return {
              "success": True,
              "message": f"Renamed {success_count} out of {len(rename_pairs_old2new)} functions",
              "success_count": success_count,
              "failed_pairs": failed_pairs
          }
  
      except Exception as e:
          print(f"Error in rename_multi_functions: {str(e)}")
          traceback.print_exc()
          return {
              "success": False,
              "message": str(e),
              "success_count": 0,
              "failed_pairs": rename_pairs_old2new
          }

• plugin/ida_mcp_server_plugin/ida_mcp_core.py:404-433 (helper)

  Helper: single function rename using ida_name.set_name() and refreshes view.

  def _rename_function_internal(self, old_name: str, new_name: str) -> Dict[str, Any]:
      """Internal implementation for rename_function without sync wrapper"""
      try:
          # Get function address
          func_addr: int = ida_name.get_name_ea(0, old_name)
          if func_addr == idaapi.BADADDR:
              return {"success": False, "message": f"Function '{old_name}' not found"}
          
          # Check if it's a function
          func: Optional[ida_funcs.func_t] = ida_funcs.get_func(func_addr)
          if not func:
              return {"success": False, "message": f"'{old_name}' is not a function"}
          
          # Check if new name is already in use
          if ida_name.get_name_ea(0, new_name) != idaapi.BADADDR:
              return {"success": False, "message": f"Name '{new_name}' is already in use"}
          
          # Try to rename
          if not ida_name.set_name(func_addr, new_name):
              return {"success": False, "message": f"Failed to rename function, possibly due to invalid name format or other IDA restrictions"}
          
          # Refresh view
          self._refresh_view_internal()
          
          return {"success": True, "message": f"Function renamed from '{old_name}' to '{new_name}' at address {hex(func_addr)}"}
      
      except Exception as e:
          print(f"Error renaming function: {str(e)}")
          traceback.print_exc()
          return {"success": False, "message": str(e)}