Copying files to multiple comp's on a lan 
Author Message
 Copying files to multiple comp's on a lan

Hi all,

I'm rather new to Python, and this is my first post in this NG (as you can
probably tell). I hope that you guys can get the meaning of my writings as
english is not my native language, so I apology beforehand for any
spelling/grammatical errors.

I need to make a small script thats capable of copying a file from the
machine that its being run on to all the other machines on the lan. The
target path on all the other machines should be the same. The script should
take the path of the source file and the remote path to the shared folder(s)
as arguments. I'll define all the machines the file is to be copied to
elsewhere.

Where do I start when making such a script? What kind of builtins should I
know of and which functions will be useful in my work? What do I need to
investigate closer (I've never tried network programming before)?

I used to do this filecopying for each machine seperately with the Windows
Explorer, and seeing as its something that I do rather often, I'm beginning
to get a little bugged by this tedious method, and have decided that now its
time to make it a little more automated.
If you know of an already existing program that can accomplish this task for
me any pointers would be greatly appreciated.

Thanks in advance,

Henrik Berg Nielsen



Wed, 19 Nov 2003 01:41:45 GMT  
 Copying files to multiple comp's on a lan
Hi once more,

I forgot to mention that the files to be copied range anywhere from 1K to
several hundred MB.

Henrik Berg Nielsen


Quote:
> Hi all,

> I'm rather new to Python, and this is my first post in this NG (as you can
> probably tell). I hope that you guys can get the meaning of my writings as
> english is not my native language, so I apology beforehand for any
> spelling/grammatical errors.

> I need to make a small script thats capable of copying a file from the
> machine that its being run on to all the other machines on the lan. The
> target path on all the other machines should be the same. The script
should
> take the path of the source file and the remote path to the shared
folder(s)
> as arguments. I'll define all the machines the file is to be copied to
> elsewhere.

> Where do I start when making such a script? What kind of builtins should I
> know of and which functions will be useful in my work? What do I need to
> investigate closer (I've never tried network programming before)?

> I used to do this filecopying for each machine seperately with the Windows
> Explorer, and seeing as its something that I do rather often, I'm
beginning
> to get a little bugged by this tedious method, and have decided that now
its
> time to make it a little more automated.
> If you know of an already existing program that can accomplish this task
for
> me any pointers would be greatly appreciated.

> Thanks in advance,

> Henrik Berg Nielsen



Wed, 19 Nov 2003 01:51:24 GMT  
 Copying files to multiple comp's on a lan
<automate copying a file to multiple destinations>

This sounds more appropriate for a shell script to me.

(First install cygwin to get a (real, useful, etc) shell
 http://sources.redhat.com/cygwin)

~~~~~~~~~~~~~ smbcopy.sh ~~~~~~~~~~~~~~~~~~~~
#!/bin/bash

IFS=":"

# In this ficticious network the machines are Mach1, Mach2, and Mach3
# and all have a samba share named 'C' which is the base path for the
# destination.

# Here is the list of machines to copy to,  I assume via Samba?
MACHINES=" //Mach1/C : //Mach2/C : //Mach3/C "

for DEST in $MACHINES ; do
    # assemble the command so as not to duplicate code
    COMMAND="cp $1 $DEST/$2"

    # display the command to the user
    echo $COMMAND

    # execute the command
    $COMMAND
done
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~

This could be done in python using a list and and a for loop, then
calling os.system( )  to do the copying,  or open the source file for
reading and iteratively open the destination files for writing and
write the data.  Ex:

~~~~~~~~~~~~ smbcopy.py ~~~~~~~~~~~~~~~~~~~~~~~~~
#!/usr/bin/env python

import sys
import os

# same as above
machines = [ "//Mach1/C" , "//Mach2/C" , "//Mach3/C" ]

source_file_path = sys.argv[1]
dest_path = sys.argv[2]

source_file = open( source_file_path , "rb" )
source_data = source_file.read()
source_file.close()

for dest in machines :
    dest_file = open( dest + "/" + dest_path , "wb" )
    dest_file.write( source_data )
    dest_file.close()
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~

Both of these sample programs assume that the input (command line
arguments) existed and were valid.  The scripts could be improved to
include more error handling and user feedback.

If you went with a python implementation you might want to create a
GUI for it (not trivial!) that would allow point-and-click selection
of files and destinations.

HTH,
-D



Wed, 19 Nov 2003 02:25:06 GMT  
 Copying files to multiple comp's on a lan

Quote:
> I need to make a small script thats capable of copying a file from the
> machine that its being run on to all the other machines on the lan. The
> target path on all the other machines should be the same. The script should
> take the path of the source file and the remote path to the shared folder(s)
> as arguments. I'll define all the machines the file is to be copied to
> elsewhere.
(...)
> I used to do this filecopying for each machine seperately with the Windows
> Explorer, and seeing as its something that I do rather often, I'm beginning
> to get a little bugged by this tedious method, and have decided that now its
> time to make it a little more automated.
> If you know of an already existing program that can accomplish this task for
> me any pointers would be greatly appreciated.

Since you mention Windows, I'd probably a Windows specific method
since you can ask Windows to identify the machines on the LAN, and use
a Win32 API call to perform the copy which in general will outperform
any other script based approach.

Here's a function from one of our upgrade scripts that replicates a
distribution tree either locally or to a specific machine.  In this
case it assumes the source tree mimics the target tree off of the
administrative share for C$ but that's easy enough to adjust or
parameterize:

    import os, win32file

    def dist_files(machine, dist_root, filelist):
        """Replicates a set of files to the target machine.  It is assumed
        that the filelist is relative to C: on the target machine"""

        if machine:
            root = r'\\%s\c$' % machine
        else:
            root = 'c:'

        for file in filelist:
            relative = os.path.normpath(os.path.splitdrive(file)[1])
            if relative[0] == os.sep:
                relative = relative[1:]
            source = dist_root + '\\' + relative
            target = root + '\\' + relative

            print '  ', source
            subdir = os.path.dirname(relative)
            check_directory(root,subdir)
            # Even if told not to complain if file exists, CopyFile will fail
            # if the file is R/O, so we always try to reset that bit
            try:
                os.chmod(target,0777)
            except:
                pass
            win32file.CopyFile(source,target,0)

This is designed such that the source tree mirrors the target location, thus
you might make a source tree like:

    C:\DIST\
           \DIR1
                \file1.txt
           \DIR2
                \file2.txt

and assuming that for the target, C:\DIST should be considered
equivalent to C:\, you could distribute this with:

    dist_files(<machine>,r'c:\dist',[r'dir1\file1.txt',r'dir2\file2.txt'])

or if you are just copying from the true file location on the source
(e.g., C: on source is C: on dest):

    dist_files(<machine>,r'c:',[filelist])

and of course you can automate the construction of the filelist if you
like (os.listdir, glob.glob, etc...)

Now, in order to determine what machines exist on the LAN, you can use
code like this (the win32net call doesn't work on Win9x - you'd have
to revert to a win32wnet approach):

    import win32api, win32net

    mymachine = win32api.GetComputerName()
    machlist = win32net.NetServerEnum(None,100)
    machines = []
    for curmachine in machlist[0]:
        name = str(curmachine['name'])
        if name != mymachine:
            machines.append(name)
    # At this point machines is a list of machines other than myself

--
-- David
--
/-----------------------------------------------------------------------\

  |             FitLinxx, Inc.            \  Phone: (203) 708-5192    |
 /  860 C{*filter*}Street, Stamford, CT  06902   \  Fax: (203) 316-5150     \
\-----------------------------------------------------------------------/



Wed, 19 Nov 2003 03:35:37 GMT  
 Copying files to multiple comp's on a lan

Quote:
>I'm rather new to Python, and this is my first post in this NG (as you can
>probably tell). I hope that you guys can get the meaning of my writings as
>english is not my native language, so I apology beforehand for any
>spelling/grammatical errors.

        So far you're writing a lot better than most native english speakers.

Quote:
>I need to make a small script thats capable of copying a file from the
>machine that its being run on to all the other machines on the lan. The
>target path on all the other machines should be the same. The script should
>take the path of the source file and the remote path to the shared folder(s)
>as arguments. I'll define all the machines the file is to be copied to
>elsewhere.

>Where do I start when making such a script? What kind of builtins should I
>know of and which functions will be useful in my work? What do I need to
>investigate closer (I've never tried network programming before)?

        First thing is what operating system is on these machines? If
most of them are Unix, there are a lot better solutions than a python
script (hey, I love Python, but there are just some times when it's
not the right tool for the job).

Quote:
>I used to do this filecopying for each machine seperately with the Windows
>Explorer, and seeing as its something that I do rather often, I'm beginning
>to get a little bugged by this tedious method, and have decided that now its
>time to make it a little more automated.
>If you know of an already existing program that can accomplish this task for
>me any pointers would be greatly appreciated.

        I'm going to assume it's windows, since you are using the
Explorer, take a look at http://optics.ph.unimelb.edu.au/help/rsync/
rsync is a pretty good way of doing what you want.
--
--
http://www.apa.org/journals/psp/psp7761121.html
It is one of the essential features of such incompetence that the person so
afflicted is incapable of knowing that he is incompetent. To have such
knowledge would already be to remedy a good portion of the offense.


Wed, 19 Nov 2003 03:17:57 GMT  
 Copying files to multiple comp's on a lan
Hm, I'd probably use the os.system() call in preference to reading the
source and then creating new destination files, as D-Man's example does,
though the choice is probably trivial and entirely personal opinion.

Example:

---------------------
 import sys
 import os

 # note Win32 uses \, not /  :)
 machines = [ "\\Mach1\C" , "\\Mach2\C" , "\\Mach3\C" ]

 source_file_path = sys.argv[1]
 dest_path = sys.argv[2]

 for machine in machines:
     # always use os.path.join() when building paths....
     dest_fullpath = os.path.join(machine, dest_path)
     cmd_string = "copy %s %s" % (source_file_path, dest_fullpath)
     os.system(cmd_string)

---------------------

You'd probably be better off if the machine/drive specs were built using
the functions in os.path as well, but that's a minor detail.  I'd also, if
I were writing this script for my own use, add a few print statements to
report on the current status, etc.... I'd also probably put the os.system()
call within a try/except block, just in case.  And of course, this all
presumes that you do have write permission on all of these machines.  :)

Jeff Shannon
Technician/Programmer
Credit International



Wed, 19 Nov 2003 08:06:02 GMT  
 Copying files to multiple comp's on a lan

Quote:
>Hm, I'd probably use the os.system() call in preference to reading the
>source and then creating new destination files, as D-Man's example does,
>though the choice is probably trivial and entirely personal opinion.

>Example:

>---------------------
> import sys
> import os

> # note Win32 uses \, not /  :)
> machines = [ "\\Mach1\C" , "\\Mach2\C" , "\\Mach3\C" ]

> source_file_path = sys.argv[1]
> dest_path = sys.argv[2]

> for machine in machines:
>     # always use os.path.join() when building paths....
>     dest_fullpath = os.path.join(machine, dest_path)
>     cmd_string = "copy %s %s" % (source_file_path, dest_fullpath)
>     os.system(cmd_string)

>---------------------

>You'd probably be better off if the machine/drive specs were built using
>the functions in os.path as well, but that's a minor detail.  I'd also, if
>I were writing this script for my own use, add a few print statements to
>report on the current status, etc.... I'd also probably put the os.system()
>call within a try/except block, just in case.  And of course, this all
>presumes that you do have write permission on all of these machines.  :)

>Jeff Shannon
>Technician/Programmer
>Credit International

It also presumes you're using Microsoft networking.

-----= Posted via Newsfeeds.Com, Uncensored Usenet News =-----
http://www.newsfeeds.com - The #1 Newsgroup Service in the World!
-----==  Over 80,000 Newsgroups - 16 Different Servers! =-----



Wed, 19 Nov 2003 09:17:47 GMT  
 Copying files to multiple comp's on a lan

Quote:


(...)
> > # note Win32 uses \, not /  :)
> > machines = [ "\\Mach1\C" , "\\Mach2\C" , "\\Mach3\C" ]

But note that you have to make these raw strings or double quote the \ for
those strings to work.  (E.g., either r"\\Mach1\C" or "\\\\Mach1\\C")

Quote:
> It also presumes you're using Microsoft networking.

True, but the original requester specifically mentioned Windows, so that's
probably a reasonable bet.

--
-- David
--
/-----------------------------------------------------------------------\

  |             FitLinxx, Inc.            \  Phone: (203) 708-5192    |
 /  860 C{*filter*}Street, Stamford, CT  06902   \  Fax: (203) 316-5150     \
\-----------------------------------------------------------------------/



Wed, 19 Nov 2003 10:27:07 GMT  
 Copying files to multiple comp's on a lan
| Hm, I'd probably use the os.system() call in preference to reading the
| source and then creating new destination files, as D-Man's example does,
| though the choice is probably trivial and entirely personal opinion.

There is a bit of technical tradeoff in the choice when using
Windows see below.

| Example:
|
| ---------------------
|  import sys
|  import os
|  
|  # note Win32 uses \, not /  :)

Yeah, but ...

|  machines = [ "\\Mach1\C" , "\\Mach2\C" , "\\Mach3\C" ]

Quote:
>>> print machines

['\\Mach1\\C', '\\Mach2\\C', '\\Mach3\\C']
Quote:
>>> print len( machines[0] )

8  
# wasn't that supposed to be 9?  and where'd that extra \ in front of
# the C come from?

backslashes are rather evil -- they tend to undergo a bit of
metamorphosis in various environments...

|  source_file_path = sys.argv[1]
|  dest_path = sys.argv[2]
|
|  for machine in machines:
|      # always use os.path.join() when building paths....
|      dest_fullpath = os.path.join(machine, dest_path)
|      cmd_string = "copy %s %s" % (source_file_path, dest_fullpath)
|      os.system(cmd_string)

Also, make sure that what cmd.exe sees here is what you expected (with
backslashes, spaces, etc.

I have no philosophical issues with this sort of technique, though
I've been bitten by the evil M$ backslashes a few times with my shell
scripts (where one script invokes another, and yet another layer of
backslash escaping is evaluated away).  I once had to label a printer
as \\\\\\\\Red1\\\\HPLaserJ (!) //Red1/HPLaserJ works much better :-).
If fact the bash script I included used the 'cp' command (the cygwin
binary of the unix command, roughly equivalent to copy.exe).

On the tutor list Tim Peters enlightened us to one of M$'s deepest
secrets -- the win32 API accepts forward slashes as a path delimiter.
I was rather relieved to learn that this (often) works from the shell
as well (bash, anyways, cmd.exe still tends to not like it).  Using
forward slashes saves a lot of headaches.

-D



Wed, 19 Nov 2003 10:07:54 GMT  
 Copying files to multiple comp's on a lan
Hi again all,

Thx for all the replys, it was really more than I expected!

I've been reading over all your suggestions and I can see that I should have
provided a bit more information about the machines involved. So here goes:

All machines, including the host which should distribute the files, run
Win2k. I have write access to all machines, and all machines have a share
called "temp" on the C drive. Likewise all machines have the same login and
password.

I've been fiddling a bit around with the various suggestions you guys made
and I can't really seem to get it to work my way. I'd prefer the Python
approach (as it seems doable and I have absolutely 0 experience on shell
programming). So far I haven't been able to access file on the remote
machines via the open() method. What should I write if I wanted to access
the file called "foo.txt" located in the "temp" folder on the C drive of the
machine named "Orion"?
I like the approach more where I let os.system() do the copying for me, but
it really doesn't work all that good if I can't assemble the proper network
paths. On a side note; what does os.sytem() do specifically?

I thank you all alot for all the fine responses, but could you next time
please be a bit more specific as I'm a rather newbie to all this stuff... :)

Also I tried "import win32api, win32file, win32net" and it can't find
neither of them, should I install these seperately or what? (plz don't laugh
:))

Thanks again,

Henrik Berg Nielsen


Quote:
> Hi all,

> I'm rather new to Python, and this is my first post in this NG (as you can
> probably tell). I hope that you guys can get the meaning of my writings as
> english is not my native language, so I apology beforehand for any
> spelling/grammatical errors.

> I need to make a small script thats capable of copying a file from the
> machine that its being run on to all the other machines on the lan. The
> target path on all the other machines should be the same. The script
should
> take the path of the source file and the remote path to the shared
folder(s)
> as arguments. I'll define all the machines the file is to be copied to
> elsewhere.

> Where do I start when making such a script? What kind of builtins should I
> know of and which functions will be useful in my work? What do I need to
> investigate closer (I've never tried network programming before)?

> I used to do this filecopying for each machine seperately with the Windows
> Explorer, and seeing as its something that I do rather often, I'm
beginning
> to get a little bugged by this tedious method, and have decided that now
its
> time to make it a little more automated.
> If you know of an already existing program that can accomplish this task
for
> me any pointers would be greatly appreciated.

> Thanks in advance,

> Henrik Berg Nielsen



Thu, 20 Nov 2003 05:38:12 GMT  
 Copying files to multiple comp's on a lan
Attached below is a script I put together that runs on a win2k box and backs
up the windows shares of other systems in the local network.  Perhaps
there's some ideas you can use.

HTH,

--

Emile van Sebille

#!python
## netBackup.py

import os
import string

from win32pipe import popen3

from time import time, localtime

def targetSystems():
    "return list of active systems on the network"
    retval = []
    systemsList = popen3("net view")[1].readlines()
    for line in systemsList:
        i = string.split(line)
        if i:
            i = i[0]
            isServer = string.find(i,'\\\\') + 1
            if isServer:
                retval.append(i)
    return retval

def backupFolderList(targetSystem):
    " return list of shares on target system that should be backed up"
    retval = []
    cmd = "net view %s" % targetSystem
    shares = popen3(cmd)[1].readlines()
    for share in shares:
        shareInfo = string.split(share)
        try:
            shareName = string.join(shareInfo[0:shareInfo.index('Disk')],'
')
            if len(shareName) != 1:
                retval.append(shareName)
        except:
            pass
    return retval

def setBackupDestination():
    today = localtime(time())
    thisMonth = today[1]
    dayOfMonth = today[2]
    dayOfWeek = today[6]    # 0(Monday) - 6(Sunday)
    dayOfYear = today[7]
    if dayOfMonth == 5:
        backUpDrive = 'HI'[thisMonth % 2]
        backupDestinationFolder = 'Monthly'
    elif dayOfWeek == 6:    #It's Sunday
        backupDrive = 'HI'[dayOfYear % 2]
        backupDestinationFolder = 'Sunday'
    else:
        backupDrive = 'HI'[dayOfWeek % 2]
        backupDestinationFolder = ['MWF','TTS'][dayOfWeek % 2]
    return r'%s:\Backups\%s' % (backupDrive, backupDestinationFolder)

def backupFolder(target, folder, backupDestination, trace=1):
    "backup contents of folder on target"

    cmd = r'xcopy "%s\%s\*.*" "%s\%s\%s" /D /E /C /I /K /X /Y' % (target,
folder, backupDestination, string.split(target,"\\")[-1],folder)

    rslt = popen3(cmd)[1].readlines()
    if trace: print rslt

def excludeSystems():
    return [r'\\spam', r'\\parrot']

def backup():
    backupDestination = setBackupDestination()
    for target in targetSystems():
        if target not in excludeSystems():
            sysName = string.split(target,r"\\")[-1]
            print "\n\nBacking up %s " % target
            folders = backupFolderList(target)
            if folders:
                if not os.path.isdir(r'%s\%s' % (backupDestination,
sysName)):
                    os.mkdir(r'%s\%s' % (backupDestination, sysName))
                open(r'%s\%s\%s' % (backupDestination, sysName,
'BackupStart'),'w').write('Backup Start Time')
                for folder in folders:
                    print "   ", folder
                    backupFolder(target, folder, backupDestination)
                open(r'%s\%s\%s' % (backupDestination, sysName,
'BackupCompleted'),'w').write(string.join(folders, '\r\n'))

if __name__ == '__main__':
    backup()



Thu, 20 Nov 2003 08:20:48 GMT  
 Copying files to multiple comp's on a lan

Quote:

> programming). So far I haven't been able to access file on the remote
> machines via the open() method. What should I write if I wanted to access
> the file called "foo.txt" located in the "temp" folder on the C drive of the
> machine named "Orion"?

In general, you need to know how the C:\TEMP directory is "shared" by
the machine "Orion".  If you have administrator rights, you will
probably find that:
    r"\\Orion\c$\temp"

will work.  In general, whatever string you can pass to the command
prompt's "dir" command to see the file can be passed to open().
Remember that Python sometimes requires backslashes to be doubled -
hence my r"..." notation above - it uses raw strings which do generally
not need slashes doubled.  ie, without raw strings, you would need to
say "\\\\Orion\\c$\\temp"

If you don't have access to the 'C$' share, then you need to investigate
the specific settings for the specific server.  There are some obscure
ways to determine this stuff programatically, but let's get the simple
things working first :)

Quote:
> I like the approach more where I let os.system() do the copying for me, but
> it really doesn't work all that good if I can't assemble the proper network
> paths.

Experiment with assembling the paths from the command prompt.

Quote:
> On a side note; what does os.sytem() do specifically?

Executes the command - almost as if you typed the command from a DOS prompt.

Quote:
> Also I tried "import win32api, win32file, win32net" and it can't find
> neither of them, should I install these seperately or what? (plz don't laugh
> :))

You probably need win32all from
http://aspn.activestate.com/ASPN/Downloads/ActivePython/Extensions/Wi...

If you installed ActivePython itself, they should all be there already.

Mark.



Thu, 20 Nov 2003 08:53:16 GMT  
 Copying files to multiple comp's on a lan
Hi again,

I got the win32all as Mark suggested and everything works like a charm now!

Just one more question:
Is it possible to

cmd_string = "copy %s %s" % ("\\Machine1\C\temp\foo.txt",
"\\Machine2\C\temp")
os.system(cmd_string)

when I am sitting and issuing the command from Machine0?
I'd like to design the script so that it copies the file to/from multiple
comps at one time, not just from the source to all the other machines one at
a time seperately, but more like:

Step 1:
copy from comp0 to comp1

Step2:
copy from comp0 to comp2
copy from comp1 to comp3

Step3:
copy from comp0 to comp4
copy from comp1 to comp5
copy from comp2 to comp6
copy from comp3 to comp7

and so on and so on...

where comp0 would be the initial source

Is this possible at all? Doing it this way would make better use of the
network, its switched, so collisions should be a problem, although the
traffic will be immense if I'm disting a 700 MB file.

All for now,

Henrik Berg Nielsen

Quote:

> > programming). So far I haven't been able to access file on the remote
> > machines via the open() method. What should I write if I wanted to
access
> > the file called "foo.txt" located in the "temp" folder on the C drive of
the
> > machine named "Orion"?

> In general, you need to know how the C:\TEMP directory is "shared" by
> the machine "Orion".  If you have administrator rights, you will
> probably find that:
>     r"\\Orion\c$\temp"

> will work.  In general, whatever string you can pass to the command
> prompt's "dir" command to see the file can be passed to open().
> Remember that Python sometimes requires backslashes to be doubled -
> hence my r"..." notation above - it uses raw strings which do generally
> not need slashes doubled.  ie, without raw strings, you would need to
> say "\\\\Orion\\c$\\temp"

> If you don't have access to the 'C$' share, then you need to investigate
> the specific settings for the specific server.  There are some obscure
> ways to determine this stuff programatically, but let's get the simple
> things working first :)

> > I like the approach more where I let os.system() do the copying for me,
but
> > it really doesn't work all that good if I can't assemble the proper
network
> > paths.

> Experiment with assembling the paths from the command prompt.

> > On a side note; what does os.sytem() do specifically?

> Executes the command - almost as if you typed the command from a DOS
prompt.

> > Also I tried "import win32api, win32file, win32net" and it can't find
> > neither of them, should I install these seperately or what? (plz don't
laugh
> > :))

> You probably need win32all from

http://aspn.activestate.com/ASPN/Downloads/ActivePython/Extensions/Wi...

- Show quoted text -

Quote:

> If you installed ActivePython itself, they should all be there already.

> Mark.



Thu, 20 Nov 2003 23:11:09 GMT  
 
 [ 13 post ] 

 Relevant Pages 

1. Copy 'DOS' File to another directory

2. Copy multiple files?

3. *** COPIED FROM: >>>Usenet/comp.arch.embe 3009 lfoss@cix.comp(1712)13Nov95 21:47

4. LAN or NOT LAN

5. Python: what's the best way to copy files on a LAN?

6. Copy files using AWK's output

7. Error handling of COPY FILE (S'87)

8. CW2.003 File copy changes the date.....need a way to copy w/o date change

9. BUG: file copy copies links as links

10. Multiple Dispatch (was Re: Replacing Multiple Inheritance with Java's Interfaces)

11. Resolving LAN's IP (with AFP?)

12. CA-5.2 print problen on LAN's

 

 
Powered by phpBB® Forum Software