---
name: "Arma 3: CfgRemoteExec"
type: topic
aliases: ["Arma 3 CfgRemoteExec", "CfgRemoteExec"]
source: https://community.bistudio.com/wiki/Arma_3:_CfgRemoteExec
revid: 369492
updated: 2024-09-06T17:55:01Z
---

# Arma 3: CfgRemoteExec

CfgRemoteExec defines rules for the remote execution of functions and commands. These rules only apply to clients. The server is not subject to any limitations, everything is enabled and allowed for it.

> [!NOTE]
> As usual, the more local config takes precedence: [Mission Description.ext](../topics/Description.ext.md) ([missionConfigFile](../commands/missionConfigFile.md)) > [Campaign Description.ext](../topics/Campaign_Description.ext.md) ([campaignConfigFile](../commands/campaignConfigFile.md)) > Game / Mod Config ([configFile](../commands/configFile.md)).
>
> If several definitions for `CfgRemoteExec` exist, the `mode` attribute will be overridden by the last parsed config and whitelisted functions and commands will be merged.
>
> To allow for a mission's mod compatibility, see [Mission Compatibility With Mods](../topics/CfgRemoteExec.md#mission-compatibility-with-mods).

See [Arma 3: Remote Execution](../topics/Remote_Execution.md) for more information about remote execution.

### Format

```cpp
class CfgRemoteExec
{
    class Functions
    {
        mode = 2;
        jip = 1;

        class BIS_fnc_someFunction
        {
            allowedTargets = 0;
            jip = 0;
        };
    };

    class Commands
    {
        mode = 1;

        class setDir
        {
            allowedTargets = 2;
            jip = 0;
        };
    };
};
```

In a `class CfgRemoteExec` block, two objects can be defined:

- Functions
  - children of this object are named like the function they filter (e.g `class BIS_fnc_showSubtitle`)
- Commands
  - children of this object are named like the command they filter (e.g `class setDir`)

Both main objects can be configured using the following values:

- `mode` - operation mode
  - 0 - remote execution is blocked
  - 1 - only whitelisted functions / commands are allowed
  - 2 - remote execution is fully allowed, ignoring the whitelist (default, because of backward compatibility)
- `jip` - [Join In Progress](../topics/Multiplayer_Scripting.md#join-in-progress) settings
  - 0 - JIP flag can not be set
  - 1 - JIP flag can be set (default)

Their elements (functions, commands) can be configured with the following values:

- `allowedTargets` - which machine can be reached by it
  - 0 - can target all machines (default)
  - 1 - can only target clients, execution on the server is denied
  - 2 - can only target the server, execution on clients is denied
- `jip` - [Join In Progress](../topics/Multiplayer_Scripting.md#join-in-progress) settings parent override
  - 0 - JIP flag can not be set
  - 1 - JIP flag can be set

### Safe Config

This config only allows required default game functions (see [Notes](../topics/CfgRemoteExec.md#notes)).

```cpp
class CfgRemoteExec
{
    class Functions
    {
        mode = 1;    // whitelist only
        jip = 0;    // JIP flag not allowed

        class BIS_fnc_effectKilledAirDestruction    { allowedTargets = 0; jip = 0; };
        class BIS_fnc_effectKilledSecondaries        { allowedTargets = 0; jip = 0; };
        class BIS_fnc_fire                            { allowedTargets = 0; jip = 0; };
        class BIS_fnc_objectVar                        { allowedTargets = 0; jip = 0; };
        class BIS_fnc_setCustomSoundController        { allowedTargets = 0; jip = 0; };

/*
        class BIS_fnc_debugConsoleExec                { allowedTargets = 0; }; //Allow debug console (optional)
*/
    };
};
```

### Mission Compatibility With Mods (Arma 3 v2.14)

A mod can define its own `CfgRemoteExec` to allow its own functions. If a mission defines it too, the mission overrides all the existing settings.

To circumvent that, use [import](../topics/import_~28Config~29.md) in the mission's [Description.ext](../topics/Description.ext.md):

```cpp
import CfgRemoteExec as CfgRemoteExecMod;

class CfgRemoteExec : CfgRemoteExecMod
{
    // your settings
};
```

### initPlayerServer.sqf

If [execVM](../commands/execVM.md) is not whitelisted, [initPlayerServer.sqf](../topics/Event_Scripts.md) will not be executed.
To have it functional without allowing [execVM](../commands/execVM.md), use the following workaround through [CfgFunctions](../topics/Functions_Library.md):

```cpp
class CfgFunctions
{
    class TAG
    {
        class Category
        {
            class initPlayerServer { file = "initPlayerServer.sqf"; };
        };
    };
};
```

```cpp
class CfgRemoteExec
{
    class Functions
    {
        mode = 1;
        class TAG_fnc_initPlayerServer { allowedTargets = 2; };
    };
};
```

Then execute it from [init.sqf](../topics/Event_Scripts.md):

```sqf
if (hasInterface) then
{
    [] spawn {
        waitUntil {!isNull player};
        [player, didJIP] remoteExec ["TAG_fnc_initPlayerServer", 2];
    };
};
```

### Default Config

> [!NOTE]
> The default `CfgRemoteExec` in the game's main config uses an outdated format and is left for backward compatibility only (it was used directly by [BIS_fnc_MP](../functions/BIS_fnc_MP.md)). The `Client` and `Server` classes are obsolete now. The new [Remote Execution Framework](../topics/Remote_Execution.md#remote-execution-framework) ignores it (by default, all functions and commands are allowed).

This is the default [config.cpp](../topics/Config.cpp~2Fbin_File_Format.md) entry (obsolete):

```cpp
class CfgRemoteExec
{
    class Server
    {
        class Functions
        {
            mode = 2;
        };
        class Commands
        {
            mode = 2;
        };
    };
    class Client
    {
        class Functions
        {
            mode = 2;
        };
        class Commands
        {
            mode = 2;
        };
    };
};
```

### Notes

> **AgentRev** (2016-01-02):
>
> - As [BIS_fnc_MP](../functions/BIS_fnc_MP.md) now uses [remoteExec](../commands/remoteExec.md), there are some functions spontaneously called by the game core that require whitelisting in order to work if `class Functions` is set to `mode = 1`:
>
>   ```cpp
>   class BIS_fnc_effectKilledAirDestruction {};
>   class BIS_fnc_effectKilledSecondaries {};
>   class BIS_fnc_fire {};
>   class BIS_fnc_objectVar {};
>   class BIS_fnc_setCustomSoundController {};
>   ```
> - For [initPlayerServer.sqf](../topics/Event_Scripts.md) to work, [BIS_fnc_execVM](../functions/BIS_fnc_execVM.md) would need to be whitelisted, but that should be avoided at all costs, as it allows hackers to bypass the whitelist. Use [this method](https://www.reddit.com/r/armadev/comments/8fkitd/initplayerserversqf_therefore_initplayerserversqf/dy5k5pf/) instead.
> - For the debug console to be able to execute anything (even locally), [BIS_fnc_debugConsoleExec](../functions/BIS_fnc_debugConsoleExec.md) must be whitelisted. This function only works when its [remoteExecutedOwner](../commands/remoteExecutedOwner.md) is [admin](../commands/admin.md), so it is safe to whitelist for everyone.
> - [remoteExec](../commands/remoteExec.md) and [remoteExecCall](../commands/remoteExecCall.md) are filtered by BattlEye's remoteexec.txt, the string analyzed by BE is formatted the same way as the following example's output:
>
>   ```sqf
>   format ["%1 %2", functionName, str arguments]
>   ```
>
>   The following remoteexec.txt exclusion can be used to safely allow all whitelisted *_fnc_* functions taking an array as parameter to go through:
>
>   ```sqf
>   !="\w+?_fnc_\w+? \[[\S\s]*\]"
>   ```
>
>   Any attempt to exploit this exclusion using other RE methods like [createUnit](../commands/createUnit.md) will run into "Error Missing ;" without any malicious code being executed. Mod makers should refrain from remote-executing raw commands from clients, as they require individual exclusions, and instead use *_fnc_* functions taking an array as parameter, which are covered by the above exclusion.

<sub>Source: [BI Community Wiki — Arma 3: CfgRemoteExec](https://community.bistudio.com/wiki/Arma_3:_CfgRemoteExec) (revision 369492).</sub>