commit 7e5a24c23a5dc004620563cc46b3db68bfc97c43 · pyrox.dev/nixpkgs

+27 -28
nixos/modules/services/networking/i2pd.nix
···

       187
       187
        
       

     

       188
       188
        
             outTunnels = mkOption {

     

       189
       189
        
               default = {};

     

       190
       190
       -
               type = with types; loaOf optionSet;

     

       190
       190
       +
               type = with types; loaOf (submodule ( 

     

       191
       191
       +
                 { name, config, ... }: {

     

       192
       192
       +
                   options = commonTunOpts name;

     

       193
       193
       +
                   config = {

     

       194
       194
       +
                     name = mkDefault name;

     

       195
       195
       +
                   };

     

       196
       196
       +
                 }

     

       197
       197
       +
               ));

     

       191
       198
        
               description = ''

     

       192
       199
        
                 Connect to someone as a client and establish a local accept endpoint

     

       193
       200
        
               '';

     

       194
       194
       -
               options = [ ({ name, config, ... }: {

     

       195
       195
       -
                 options = commonTunOpts name;

     

       196
       196
       -
                 config = {

     

       197
       197
       -
                   name = mkDefault name;

     

       198
       198
       -
                 };

     

       199
       199
       -
               }) ];

     

       200
       201
        
             };

     

       201
       202
        
       

     

       202
       203
        
             inTunnels = mkOption {

     

       203
       204
        
               default = {};

     

       204
       204
       -
               type = with types; loaOf optionSet;

     

       205
       205
       +
               type = with types; loaOf (submodule (

     

       206
       206
       +
                 { name, config, ... }: {

     

       207
       207
       +
                   options = {

     

       208
       208
       +
                     inPort = mkOption {

     

       209
       209
       +
                       type = types.int;

     

       210
       210
       +
                       default = 0;

     

       211
       211
       +
                       description = "Service port. Default to the tunnel's listen port.";

     

       212
       212
       +
                     };

     

       213
       213
       +
                     accessList = mkOption {

     

       214
       214
       +
                       type = with types; listOf str;

     

       215
       215
       +
                       default = [];

     

       216
       216
       +
                       description = "I2P nodes that are allowed to connect to this service.";

     

       217
       217
       +
                     };

     

       218
       218
       +
                   } // commonTunOpts name;

     

       219
       219
       +
                   config = {

     

       220
       220
       +
                     name = mkDefault name;

     

       221
       221
       +
                   };

     

       222
       222
       +
                 }

     

       223
       223
       +
               ));

     

       205
       224
        
               description = ''

     

       206
       225
        
                 Serve something on I2P network at port and delegate requests to address inPort.

     

       207
       226
        
               '';

     

       208
       208
       -
               options = [ ({ name, config, ... }: {

     

       209
       209
       -
       

     

       210
       210
       -
                 options = {

     

       211
       211
       -
                   inPort = mkOption {

     

       212
       212
       -
                     type = types.int;

     

       213
       213
       -
                     default = 0;

     

       214
       214
       -
                     description = "Service port. Default to the tunnel's listen port.";

     

       215
       215
       -
                   };

     

       216
       216
       -
                   accessList = mkOption {

     

       217
       217
       -
                     type = with types; listOf str;

     

       218
       218
       -
                     default = [];

     

       219
       219
       -
                     description = "I2P nodes that are allowed to connect to this service.";

     

       220
       220
       -
                   };

     

       221
       221
       -
                 } // commonTunOpts name;

     

       222
       222
       -
       

     

       223
       223
       -
                 config = {

     

       224
       224
       -
                   name = mkDefault name;

     

       225
       225
       -
                 };

     

       226
       226
       -
       

     

       227
       227
       -
               }) ];

     

       228
       227
        
             };

     

       229
       228
        
           };

     

       230
       229
        
         };