perlport.1

视频监控网络部分的协议ddns,的模块的实现代码,请大家大胆指正.

.PP
Don't assume that a single \f(CW\*(C`unlink\*(C'\fR completely gets rid of the file:
some filesystems (most notably the ones in \s-1VMS\s0) have versioned
filesystems, and \fIunlink()\fR removes only the most recent one (it doesn't
remove all the versions because by default the native tools on those
platforms remove just the most recent version, too).  The portable
idiom to remove all the versions of a file is
.PP
.Vb 1
\&    1 while unlink "file";
.Ve
.PP
This will terminate if the file is undeleteable for some reason
(protected, not there, and so on).
.PP
Don't count on a specific environment variable existing in \f(CW%ENV\fR.
Don't count on \f(CW%ENV\fR entries being case-sensitive, or even
case-preserving.  Don't try to clear \f(CW%ENV\fR by saying \f(CW\*(C`%ENV = ();\*(C'\fR, or,
if you really have to, make it conditional on \f(CW\*(C`$^O ne \*(AqVMS\*(Aq\*(C'\fR since in
\&\s-1VMS\s0 the \f(CW%ENV\fR table is much more than a per-process key-value string
table.
.PP
On \s-1VMS\s0, some entries in the \f(CW%ENV\fR hash are dynamically created when
their key is used on a read if they did not previously exist.  The
values for \f(CW$ENV{HOME}\fR, \f(CW$ENV{TERM}\fR, \f(CW$ENV{HOME}\fR, and \f(CW$ENV{USER}\fR,
are known to be dynamically generated.  The specific names that are
dynamically generated may vary with the version of the C library on \s-1VMS\s0,
and more may exist than is documented.
.PP
On \s-1VMS\s0 by default, changes to the \f(CW%ENV\fR hash are persistent after the process
exits.  This can cause unintended issues.
.PP
Don't count on signals or \f(CW%SIG\fR for anything.
.PP
Don't count on filename globbing.  Use \f(CW\*(C`opendir\*(C'\fR, \f(CW\*(C`readdir\*(C'\fR, and
\&\f(CW\*(C`closedir\*(C'\fR instead.
.PP
Don't count on per-program environment variables, or per-program current
directories.
.PP
Don't count on specific values of \f(CW$!\fR, neither numeric nor
especially the strings values\*(-- users may switch their locales causing
error messages to be translated into their languages.  If you can
trust a POSIXish environment, you can portably use the symbols defined
by the Errno module, like \s-1ENOENT\s0.  And don't trust on the values of \f(CW$!\fR
at all except immediately after a failed system call.
.Sh "Command names versus file pathnames"
.IX Subsection "Command names versus file pathnames"
Don't assume that the name used to invoke a command or program with
\&\f(CW\*(C`system\*(C'\fR or \f(CW\*(C`exec\*(C'\fR can also be used to test for the existence of the
file that holds the executable code for that command or program.
First, many systems have \*(L"internal\*(R" commands that are built-in to the
shell or \s-1OS\s0 and while these commands can be invoked, there is no
corresponding file.  Second, some operating systems (e.g., Cygwin,
\&\s-1DJGPP\s0, \s-1OS/2\s0, and \s-1VOS\s0) have required suffixes for executable files;
these suffixes are generally permitted on the command name but are not
required.  Thus, a command like \*(L"perl\*(R" might exist in a file named
\&\*(L"perl\*(R", \*(L"perl.exe\*(R", or \*(L"perl.pm\*(R", depending on the operating system.
The variable \*(L"_exe\*(R" in the Config module holds the executable suffix,
if any.  Third, the \s-1VMS\s0 port carefully sets up $^X and
\&\f(CW$Config\fR{perlpath} so that no further processing is required.  This is
just as well, because the matching regular expression used below would
then have to deal with a possible trailing version number in the \s-1VMS\s0
file name.
.PP
To convert $^X to a file pathname, taking account of the requirements
of the various operating system possibilities, say:
.PP
.Vb 4
\&  use Config;
\&  $thisperl = $^X;
\&  if ($^O ne \*(AqVMS\*(Aq)
\&     {$thisperl .= $Config{_exe} unless $thisperl =~ m/$Config{_exe}$/i;}
.Ve
.PP
To convert \f(CW$Config\fR{perlpath} to a file pathname, say:
.PP
.Vb 4
\&  use Config;
\&  $thisperl = $Config{perlpath};
\&  if ($^O ne \*(AqVMS\*(Aq)
\&     {$thisperl .= $Config{_exe} unless $thisperl =~ m/$Config{_exe}$/i;}
.Ve
.Sh "Networking"
.IX Subsection "Networking"
Don't assume that you can reach the public Internet.
.PP
Don't assume that there is only one way to get through firewalls
to the public Internet.
.PP
Don't assume that you can reach outside world through any other port
than 80, or some web proxy.  ftp is blocked by many firewalls.
.PP
Don't assume that you can send email by connecting to the local \s-1SMTP\s0 port.
.PP
Don't assume that you can reach yourself or any node by the name
\&'localhost'.  The same goes for '127.0.0.1'.  You will have to try both.
.PP
Don't assume that the host has only one network card, or that it
can't bind to many virtual \s-1IP\s0 addresses.
.PP
Don't assume a particular network device name.
.PP
Don't assume a particular set of \fIioctl()\fRs will work.
.PP
Don't assume that you can ping hosts and get replies.
.PP
Don't assume that any particular port (service) will respond.
.PP
Don't assume that Sys::Hostname (or any other \s-1API\s0 or command)
returns either a fully qualified hostname or a non-qualified hostname:
it all depends on how the system had been configured.  Also remember
things like \s-1DHCP\s0 and NAT\*(-- the hostname you get back might not be very
useful.
.PP
All the above \*(L"don't\*(R":s may look daunting, and they are \*(-- but the key
is to degrade gracefully if one cannot reach the particular network
service one wants.  Croaking or hanging do not look very professional.
.Sh "Interprocess Communication (\s-1IPC\s0)"
.IX Subsection "Interprocess Communication (IPC)"
In general, don't directly access the system in code meant to be
portable.  That means, no \f(CW\*(C`system\*(C'\fR, \f(CW\*(C`exec\*(C'\fR, \f(CW\*(C`fork\*(C'\fR, \f(CW\*(C`pipe\*(C'\fR,
\&\f(CW\*(C`\`\`\*(C'\fR, \f(CW\*(C`qx//\*(C'\fR, \f(CW\*(C`open\*(C'\fR with a \f(CW\*(C`|\*(C'\fR, nor any of the other things
that makes being a perl hacker worth being.
.PP
Commands that launch external processes are generally supported on
most platforms (though many of them do not support any type of
forking).  The problem with using them arises from what you invoke
them on.  External tools are often named differently on different
platforms, may not be available in the same location, might accept
different arguments, can behave differently, and often present their
results in a platform-dependent way.  Thus, you should seldom depend
on them to produce consistent results. (Then again, if you're calling 
\&\fInetstat \-a\fR, you probably don't expect it to run on both Unix and \s-1CP/M\s0.)
.PP
One especially common bit of Perl code is opening a pipe to \fBsendmail\fR:
.PP
.Vb 2
\&    open(MAIL, \*(Aq|/usr/lib/sendmail \-t\*(Aq) 
\&        or die "cannot fork sendmail: $!";
.Ve
.PP
This is fine for systems programming when sendmail is known to be
available.  But it is not fine for many non-Unix systems, and even
some Unix systems that may not have sendmail installed.  If a portable
solution is needed, see the various distributions on \s-1CPAN\s0 that deal
with it.  Mail::Mailer and Mail::Send in the MailTools distribution are
commonly used, and provide several mailing methods, including mail,
sendmail, and direct \s-1SMTP\s0 (via Net::SMTP) if a mail transfer agent is
not available.  Mail::Sendmail is a standalone module that provides
simple, platform-independent mailing.
.PP
The Unix System V \s-1IPC\s0 (\f(CW\*(C`msg*(), sem*(), shm*()\*(C'\fR) is not available
even on all Unix platforms.
.PP
Do not use either the bare result of \f(CW\*(C`pack("N", 10, 20, 30, 40)\*(C'\fR or
bare v\-strings (such as \f(CW\*(C`v10.20.30.40\*(C'\fR) to represent IPv4 addresses:
both forms just pack the four bytes into network order.  That this
would be equal to the C language \f(CW\*(C`in_addr\*(C'\fR struct (which is what the
socket code internally uses) is not guaranteed.  To be portable use
the routines of the Socket extension, such as \f(CW\*(C`inet_aton()\*(C'\fR,
\&\f(CW\*(C`inet_ntoa()\*(C'\fR, and \f(CW\*(C`sockaddr_in()\*(C'\fR.
.PP
The rule of thumb for portable code is: Do it all in portable Perl, or
use a module (that may internally implement it with platform-specific
code, but expose a common interface).
.Sh "External Subroutines (\s-1XS\s0)"
.IX Subsection "External Subroutines (XS)"
\&\s-1XS\s0 code can usually be made to work with any platform, but dependent
libraries, header files, etc., might not be readily available or
portable, or the \s-1XS\s0 code itself might be platform-specific, just as Perl
code might be.  If the libraries and headers are portable, then it is
normally reasonable to make sure the \s-1XS\s0 code is portable, too.
.PP
A different type of portability issue arises when writing \s-1XS\s0 code:
availability of a C compiler on the end-user's system.  C brings
with it its own portability issues, and writing \s-1XS\s0 code will expose
you to some of those.  Writing purely in Perl is an easier way to
achieve portability.
.Sh "Standard Modules"
.IX Subsection "Standard Modules"
In general, the standard modules work across platforms.  Notable
exceptions are the \s-1CPAN\s0 module (which currently makes connections to external
programs that may not be available), platform-specific modules (like
ExtUtils::MM_VMS), and \s-1DBM\s0 modules.
.PP
There is no one \s-1DBM\s0 module available on all platforms.
SDBM_File and the others are generally available on all Unix and DOSish
ports, but not in MacPerl, where only NBDM_File and DB_File are
available.
.PP
The good news is that at least some \s-1DBM\s0 module should be available, and
AnyDBM_File will use whichever module it can find.  Of course, then
the code needs to be fairly strict, dropping to the greatest common
factor (e.g., not exceeding 1K for each record), so that it will
work with any \s-1DBM\s0 module.  See AnyDBM_File for more details.
.Sh "Time and Date"
.IX Subsection "Time and Date"
The system's notion of time of day and calendar date is controlled in
widely different ways.  Don't assume the timezone is stored in \f(CW$ENV{TZ}\fR,
and even if it is, don't assume that you can control the timezone through
that variable.  Don't assume anything about the three-letter timezone
abbreviations (for example that \s-1MST\s0 would be the Mountain Standard Time,
it's been known to stand for Moscow Standard Time).  If you need to
use timezones, express them in some unambiguous format like the
exact number of minutes offset from \s-1UTC\s0, or the \s-1POSIX\s0 timezone
format.
.PP
Don't assume that the epoch starts at 00:00:00, January 1, 1970,
because that is \s-1OS\-\s0 and implementation-specific.  It is better to
store a date in an unambiguous representation.  The \s-1ISO\s0 8601 standard
defines YYYY-MM-DD as the date format, or YYYY-MM-DDTHH-MM-SS
(that's a literal \*(L"T\*(R" separating the date from the time).
Please do use the \s-1ISO\s0 8601 instead of making us to guess what
date 02/03/04 might be.  \s-1ISO\s0 8601 even sorts nicely as-is.
A text representation (like \*(L"1987\-12\-18\*(R") can be easily converted
into an OS-specific value using a module like Date::Parse.
An array of values, such as those returned by \f(CW\*(C`localtime\*(C'\fR, can be
converted to an OS-specific representation using Time::Local.
.PP
When calculating specific times, such as for tests in time or date modules,
it may be appropriate to calculate an offset for the epoch.
.PP
.Vb 2
\&    require Time::Local;
\&    $offset = Time::Local::timegm(0, 0, 0, 1, 0, 70);
.Ve
.PP
The value for \f(CW$offset\fR in Unix will be \f(CW0\fR, but in Mac \s-1OS\s0 will be
some large number.  \f(CW$offset\fR can then be added to a Unix time value
to get what should be the proper value on any system.
.PP
On Windows (at least), you shouldn't pass a negative value to \f(CW\*(C`gmtime\*(C'\fR or
\&\f(CW\*(C`localtime\*(C'\fR.
.Sh "Character sets and character encoding"
.IX Subsection "Character sets and character encoding"
Assume very little about character sets.
.PP
Assume nothing about numerical values (\f(CW\*(C`ord\*(C'\fR, \f(CW\*(C`chr\*(C'\fR) of characters.
Do not use explicit code point ranges (like \exHH\-\exHH); use for
example symbolic character classes like \f(CW\*(C`[:print:]\*(C'\fR.
.PP
Do not assume that the alphabetic characters are encoded contiguously
(in the numeric sense).  There may be gaps.
.PP
Do not assume anything about the ordering of the characters.
The lowercase letters may come before or after the uppercase letters;
the lowercase and uppercase may be interlaced so that both \*(L"a\*(R" and \*(L"A\*(R"
come before \*(L"b\*(R"; the accented and other international characters may
be interlaced so that a\*: comes before \*(L"b\*(R".
.Sh "Internationalisation"
.IX Subsection "Internationalisation"
If you may assume \s-1POSIX\s0 (a rather large assumption), you may read
more about the \s-1POSIX\s0 locale system from perllocale.  The locale
system at least attempts to make things a little bit more portable,
or at least more convenient and native-friendly for non-English
users.  The system affects character sets and encoding, and date
and time formatting\*(--amongst other things.
.PP
If you really want to be international, you should consider Unicode.
See perluniintro and perlunicode for more information.
.PP
If you want to use non-ASCII bytes (outside the bytes 0x00..0x7f) in
the \*(L"source code\*(R" of your code, to be portable you have to be explicit
about what bytes they are.  Someone might for example be using your
code under a \s-1UTF\-8\s0 locale, in which case random native bytes might be
illegal (\*(L"Malformed \s-1UTF\-8\s0 ...\*(R")  This means that for example embedding
\&\s-1ISO\s0 8859\-1 bytes beyond 0x7f into your strings might cause trouble
later.  If the bytes are native 8\-bit bytes, you can use the \f(CW\*(C`bytes\*(C'\fR
pragma.  If the bytes are in a string (regular expression being a
curious string), you can often also use the \f(CW\*(C`\exHH\*(C'\fR notation instead
of embedding the bytes as-is.  (If you want to write your code in \s-1UTF\-8\s0,
you can use the \f(CW\*(C`utf8\*(C'\fR.) The \f(CW\*(C`bytes\*(C'\fR and \f(CW\*(C`utf8\*(C'\fR pragmata are
available since Perl 5.6.0.
.Sh "System Resources"
.IX Subsection "System Resources"
If your code is destined for systems with severely constrained (or
missing!) virtual memory systems then you want to be \fIespecially\fR mindful
of avoiding wasteful constructs such as:
.PP
.Vb 3
\&    # NOTE: this is no longer "bad" in perl5.005
\&    for (0..10000000) {}                       # bad