---
name: "Net::TFTPd"
section: "3pm"
platform: "linux"
package: "libnet-tftpd-perl"
version: "0.10-3"
release: "Debian 13 (Trixie)"
platforms: ["linux"]
url: "https://new.carta.tech/Net::TFTPd"
---

# Net::TFTPd(3pm)

Perl extension for Trivial File Transfer Protocol Server

## NAME

Net::TFTPd - Perl extension for Trivial File Transfer Protocol Server

## SYNOPSIS

```
  use strict;
  use Net::TFTPd;
  my $tftpdOBJ = Net::TFTPd->new('RootDir' => 'path/to/files')
    or die "Error creating TFTPd listener: %s", Net::TFTPd->error;
  my $tftpRQ = $tftpdOBJ->waitRQ(10)
    or die "Error waiting for TFTP request: %s", Net::TFTPd->error;
  $tftpRQ->processRQ()
    or die "Error processing TFTP request: %s", Net::TFTPd->error;
  printf "%u bytes has been transferred", $tftpRQ->getTotalBytes() || 0;
```

## DESCRIPTION

`"Net::TFTPd"` is a class implementing a simple *Trivial File Transfer Protocol* server in Perl as described in RFC1350.

`"Net::TFTPd"` also supports the TFTP Option Extension (as described in RFC2347), with the following options:

```
  RFC2348 TFTP Blocksize Option
  RFC2349 TFTP Timeout Interval and Transfer Size Options
```

## EXPORT

None by default.

### %OPCODES

The `%OPCODES` tag exports the *%OPCODES* hash:

```
  %OPCODES = (
    1       => 'RRQ',
    2       => 'WRQ',
    3       => 'DATA',
    4       => 'ACK',
    5       => 'ERROR',
    6       => 'OACK',
    'RRQ'   => 1,
    'WRQ'   => 2,
    'DATA'  => 3,
    'ACK'   => 4,
    'ERROR' => 5,
    'OACK'  => 6
  );
```

## Listener constructor

### new()

```
  $listener = new Net::TFTPd( ['RootDir' => 'path/to/files' | 'FileName' => 'path/to/file'] [, OPTIONS ] );
```

or

```
  $listener = Net::TFTPd->new( ['RootDir' => 'path/to/files' | 'FileName' => 'path/to/file'] [, OPTIONS ] );
```

Create a new Net::TFTPd object where 'path/to/files' is the default path to file repository or 'path/to/file' is the single file allowed for download, and OPTIONS are the default server options.

Valid options are:

```
  Option     Description                                        Default
  ------     -----------                                        -------
  LocalAddr  Interface to bind to (for multi-homed server)          any
  LocalPort  Port to bind server to                                  69
  Timeout    Timeout in seconds to wait for a request                10
  ACKtimeout Timeout in seconds to wait for an ACK packet             4
  ACKretries Maximum number of retries waiting for ACK                4
  Readable   Clients are allowed to read files                        1
  Writable   Clients are allowed to write files                       0
  BlkSize    Minimum blocksize to negotiate for transfers           512
  CallBack   Reference to code executed for each transferred block    -
  Debug      Activates debug mode (verbose)                           0
  Family     Address family IPv4/IPv6                              IPv4
               Valid values for IPv4:
                 4, v4, ip4, ipv4, AF_INET (constant)
               Valid values for IPv6:
                 6, v6, ip6, ipv6, AF_INET6 (constant)
  V6Only     Enable / disable v6only (see IO::Socket::IP)             1
```

**NOTE**:  IPv6 requires **IO::Socket::IP**.  Failback is **IO::Socket::INET**  and only IPv4 support.

### CallBack

The CallBack code is called by processRQ method for each tranferred block.

The code receives (into `@_` array) a reference to internal *$request* object.

Example:

```
  sub callback
  {
    my $req = shift;
    printf "block: %u\/%u\n", $req->{'_REQUEST_'}{'LASTACK'}, $req->{'_REQUEST_'}{'LASTBLK'};
  }
  my $tftpdOBJ = Net::TFTPd->new('RootDir' => 'c:/temp', 'Timeout' => 60, 'CallBack' => \&callback) or die Net::TFTPd->error;
```

## Listener methods

### waitRQ()

```
  $request = $listener->waitRQ([Timeout]);
```

Waits for a client request (RRQ or WRQ) and returns a *$request* object or *undef* if timed out.

If *Timeout* is missing, the timeout defined for *$listener* object is used instead.

When the method returns, the program should **fork()** and process the request invoking **processRQ()** while the parent process should re-start waiting for another request.

## Request methods

### processRQ()

```
  $ret = $request->processRQ();
```

Processes a request and returns 1 if success, undef if error.

### getFileName()

```
  $ret = $request->getFileName();
```

Returns the requested file name.

### getMode()

```
  $ret = $request->getMode();
```

Returns the transfer mode for the request.

### getBlkSize()

```
  $ret = $request->getBlkSize();
```

Returns the block size used for the transfer.

### server()

```
  $ret = $request->server();
```

Return **IO::Socket::\*** object for the created server.   All **IO::Socket::\*** accessors can then be called.

### getPeerAddr()

```
  $ret = $request->getPeerAddr();
```

Returns the address of the requesting client.

### getPeerPort()

```
  $ret = $request->getPeerMode();
```

Returns the port of the requesting client.

### getTotalBytes()

```
  $ret = $request->getTotalBytes();
```

Returns the number of bytes transferred for the request.

## CREDITS

Thanks to Michael Vincent (\<VINSWORLD\>) for the NETASCII support, transferred bytes and IPv6 patches.

## AUTHOR

Luigino Masarati, \<lmasarati@hotmail.com\>

## SEE ALSO

Net::TFTP.