FTP process

Here is my problem.
The NT server sending FAT files (thru' FTP) to Sun server frequently.
The processing engine in Sun server pick up these files, once it deducts the files
in the input location. My problems come, some time the unexpected delay in the FTP process
The processing engine pick up the files for processing while the FTP is in progress.
Some of my friends told me " processes cannot take a input file for processing
While the FTP process has not completed fully. In SunOS, attempting to access any
File for processing which is under FTP process will fail"
Is it true? Pls reply me asap.
Thanks.
Gani

This may or may not be true in SunOS. It is certainly not true in other operating systems.
It should not be hard to set up a test -- start uploading a very large file to your server, and try reading it via a program while the upload is still taking place.

Similar Messages

File format while sending a file using FTP Process

Hi,
I am facing a formatting problem when i send a file from SAP application server to a different sever using FTP process.
The problem is like this:
Lets say I have a file with 10 records on the application server. When i am downloading this file to a pc, the file is showing 10 lines.
But when i open the same file on the other server it is showing 10 records as 1 line.
The file i am sending is a text file.(ex: acc_payable.txt)
If i open the same file on the other server using word pad it is showing 10 records in 10 different lines.
I want the file to be opened using notepad and want to see the each record in a different line
Can anybody help me on this issue
Regards,
Radhakrishna

Another stab at "simplest": can you avoid embedding
newline characters in the strings
your write and reply on PrintWriter's
println() methods instead?But, if I understand the OP, this will cause the same problem. He is running on Unix but wants to generate a DOS type eol. The println() method will use the OS default; therefore, he needs to explicitly specify the DOS eol.

FTP process flow not using registered userid

Hi,
I posted the following last week, to the back of a thread that Igor was answering to, but haven't seen any replies yet. Can some body answer the question regarding the userid used on the target location when an FTP process flow is ran please?
Thanks again.
==================
Igor,
I followed the examples given in this thread, and checked the case study in the PDF, but am still not able to 'get' a file using FTP to the desired location.
I have an FTP work flow configured with the Path Settings pointing to: REMOTE LOCATION is a w2k server, WORKING LOCATION is on Unix. These locations are registered in the Deployment Mgr properly.
I am able to PUT a file to win2k from Unix, but not GET.
This is caused by the fact that, during FTP WF execution, it is ran as Unix user 'oracle', whom do not have write access to the Root Path registered for the WORKING LOCATION. (I can do a get to /tmp).
Also, I am getting these messages in the execution log, even if the FTP was successful:
WARNING: Log file truncated - see RAB for further information.
ftp: ioctl I_PUSH ttcompat: No such device or address
ftp: ioctl(TIOCGETP): No such device or address
All of these problems indicate that the run time Unix user, 'oracle', doesn't have sufficient rights to various directories. Is it possible to force OWB use the userid that was registered for the WORKING LOCATION?
Thanks.

Hi,
Please follow the below steps.
1. Kill the OWF process using the Oracle Workflow Monitor.
- On the OWF Monitor home page, use "Find Process" to find the process
- In the "Process List" page, click on the Process Name
- Click on the "View Diagram" button
- Click on the "Abort Process" button
In the process list, the process should have a white-black flag.
2. Connect as the Workflow schema owner and execute the following commands in order to purge the item type.
- WF_PURGE.TOTAL package : deletes obsolete runtime data which includes: Items, Item activity statuses, Notifications, Expired activity versions.
SQL> execute wf_purge.total
- WFRMITT.sql script : deletes all definitions for an Item.
SQL> @< database_oracle_home> wf\admin\sql\WFRMITT.sql
3. Deploy the Workflow Process again from the OWB Deployment Manager.
Thanks,
Leo.

File adapter causes FTP process stop result 0 byte file.

Has anyone ever heard that FTP adapter can cause FTP process to stop and end up with 0 byte file transferred?
We use the normal ftp script to ftp file from external file server place file in XI inbound folder so that file adapter can pick them up from that folder.
We have encounter a few 0 byte FTPed file in our system. One suspecting is the network between XI server and file server might get some interruption. With out just blaming on the network. We would like to know if there is any possibility that it is also causes by our file adapter? Says, it try to read the file that is not yet complete transferring make FTP give up transferring??
We would like to know if FTP process is transferring the file over and file adapter try to read, what will happen? Will it read file with incomplete content and ftp still go on? Or will it stop reading and return back error as the file could not be open? Or it will force FTP process to let go the file??
Best rgds,
Thida

Hi,
>We would like to know if there is any possibility that it is also causes by our file adapter? Says, it try to read the file that is not yet complete transferring make FTP give up transferring??
have not seen the file adapter causing any such problems. So, it looks like a network issue.
>We would like to know if FTP process is transferring the file over and file adapter try to read, what will happen? Will it read file with incomplete content and ftp still go on? Or will it stop reading and return back error as the file could not be open? Or it will force FTP process to let go the file??
Am not exactly sure, but when a file is being created and the file adapter tries to read such a file, the file would be READ and WRITE Locked and so File adapter should not be able to read such a file until the creation of the file is complete.
Also, take a look at the note : 821267 , question 31 for how file adapter processes empty file.
Regards,
Bhavesh

Run separate "FTP" Process

I want to execute Ftp process when executing the program,but it is not working properly, what is wrong in the code.If it is wrong how to do?
anything wrong in the following code plz suggest me.
public class check
public static void main(String[] args) throws Exception
Runtime r = Runtime.getRuntime();
r.exec("cmd /C FTP -s:process.txt 10.0.1.201");
plz suggest.
with regards
-Raja.

Maybe you need to wait for the process to finish (process.waitFor())? Try seeing if there is any error output from "ftp":
import java.io.*;
public class t
    public static void main(String[] args)
        throws Exception
        Runtime r = Runtime.getRuntime();
        Process process = r.exec("cmd /C FTP -s:process.txt 10.0.1.201");
        BufferedReader in = new BufferedReader(new InputStreamReader(process.getErrorStream()));
        while (true) {
            String line = in.readLine();
            if (line == null)
                break;
            System.out.println("err: " + line);

Need documentation to build ftp process

Hello,
I am new to PI 7 and I am trying to create a FTP process to send a file from a external server to SAP. I am using the intregration builder to build the process. I am looking at some processes that have already been built to help me create my process. these processes use the communication component, communication channel, and integrated configurations. I am trying to find some documentation that tells me how to code these sections and what values get populated in the various tabs. example - I am not sure what a namespace is and where it gets built.
thanks in advance for the help

Hi,
refer these links to configure your scenario
https://wiki.sdn.sap.com/wiki/display/XI/FileToIDOC
https://wiki.sdn.sap.com/wiki/display/XI/FILETORFCTOFILEwithBPM
https://wiki.sdn.sap.com/wiki/display/XI/File-RFC-File(Without+BPM)
http://help.sap.com/saphelp_nw04/helpdata/en/2c/181077dd7d6b4ea6a8029b20bf7e55/content.htm
To configure FTP:
https://weblogs.sdn.sap.com/cs/user/view/cs_msg/12420
Regards,
Nithiyanandam

PI FTP: Process 1 file at a time until it is successfully processed at the target system

Dear Experts,
As the title said, I'm required to process 1 file at a time and only process the next file after the previous file has been successfully processed at the target system. The interface scenario is asynchronous FTP to ABAP proxy.
It is similar with the following link:
File adapter to pick a single file
I think there could be 2 feasible solutions:
1. Configure EOIO at the sender CC. According to this link:
     Queues for Asynchronous Message Processing (SAP Library - SAP NetWeaver Exchange Infrastructure)
     It is stated that "Once the message has been processed successfully in the target system, the Integration Engine executes an implicit database commit."
     In the case of asynchronous FTP to ABAP proxy, will the PI wait for the ABAP proxy to finish processing the file before sending the next one?
2. Configure locking at the ABAP program in ECC. I could ask the ABAPer to create a locking mechanism to lock the document before it is posted to BAPI. If the reference document is being locked, it will try again for the next second up to a certain times before it gives up.
Which 1 is actually fits the requirement?
Thank you,
Suwandi C.

Dear Experts,
Sorry, just 1 more question which I'm curious.
In NFS adapter we have the option to set the processing sequence to by Name / Date.
In FTP will it only by Date?
According to this link:
https://help.sap.com/saphelp_nw73/helpdata/en/f9/17888f490846a9972628525cc28aac/content.htm
"Messages are delivered with the same queue names (supplied by the application) in the same sequence that they were sent from the sender system"
If it is in the same sequence sent by the sender, I guess it is in the Date order for FTP. Is that correct?
Thank you,
Suwandi C.

File sender adapter (FTP) - processing mode "Archive"

Hello all
We're polling files from an external FTP server. For this I created a scenario on XI according to this thread:
When setting processing mode to "Archive" in the file sender adapter (ftp) it polls the file, stores it to the archive directory I specified and then tries to delete the file on the FTP server side. This returns me an error because we're not allowed to delete the retrieved files on the FTP server!
Because of this error the file adapter stops further processing and does not poll all the other files.
How can I disable this deletion mechanism while keeping processing mode to "Archive"?!?!?
We do not want to use processing mode "Delete" or "Test" and we don't see other options to influence this behaviour.
Thanks for any guideance on this one in advance!
Kind regards,
Renaud

Hi Bhavesh
Sorry for the late answer. Unfortunately I can't ask the application system to provide file names containing a timestamp within. The files are provided by an external partner and are retrieved by several others as well.
In the meantime I managed to achieve this:
In repository I created dummy data types, message types and message interfaces. No mapping programs and interface mappings!
In configuration I created the necessary communication channels (1 ftp sender, 1 file receiver) and the required receiver and interface determinations as well as the sender and receiver agreements.
The result of this is:
I'm able to poll some specific files via ftp from remote host. The file names are file1.arj, file2.arj, file3.arj and file4.arj. All 4 files have the same SourceFileTimestamp (e.g. "20060727T053900Z").
I'm able to store those 4 files 1:1 in a target directory with the same file names. Until here I did NOT need to follow this blog: <a href="/people/michal.krawczyk2/blog/2005/11/10/xi-the-same-filename-from-a-sender-to-a-receiver-file-adapter--sp14: The same filename from a sender to a receiver file adapter - SP14</a>.
As of this blog it is possible to access adapter specific attributes and make them available in message mapping using user defined functions. This way I'm able to get the SourceFileTimestamp from the polled files and use it in a message mapping. This way I'm also able to use it in variable substitution on file receiver adapter (syntax = "payload:root,1,fileTS,1") in order to dynamically create a directory with this syntax: YYYYMMDD.
So far so good... but the only remaining BIG problem now is, that as soon as the mapping is activated and assigned in the interface determination, the created files contain the XML payload instead of the original binary content. Where has it gone? How should the target message type look like so that it can carry over the original binary file content?
BTW: isn't it possible to post screenshots? Would be much more easier to explain things... so sorry to anyone if I wasn't clear enough!
TIA and best regards,
Renaud

FTP processing files mutliple times

Hello,
I have an issue, regarding the ftp scenario. I have configured the Quality of Service to "Exactly Once", Poll interval 120 seconds. I doubt that its performing as desired, because I see many files were processed many times.
My question is whats is the purpose of Exactly once and Exactly once in order. what if poll interval is small and execution overlaps i.e. first process in execution and poll interval reaches for second execution and so forth?
I want that any file written should be read once only.
Quick responses will be highly appreciated.
Jawed

Hi Javed,
>>Poll interval is small and execution overlaps i.e. first process in execution and poll interval reaches for second execution and so forth?
In EO case
1. all files from first process will be available (say 10).
2. second process starts (say 5 files from 1st process are still there to be processed) and 5 files are made available to XI
3. now XI need to process total 10 file
So in-total there were 15 files and all will be processed once and for each of them there will be an output from XI. But there is no guarantee that the first 10 files (of 1st process) will be delivered first and then the 5 files (2nd file)
In EOIO case
1. all files from first process will be available (say 10 files are available).
2. Since the mode is EOIO, all files are punt into one queue (say INPUTQUEUEU)
3. second process starts (say 5 files from 1st process are still there to be processed in INPUTQUEUE) and 5 files are made available to XI
4. They will also be appended to the end of the INPUTQUEUE.
3. Now XI need to process total 10 file
So in-total there were 15 files and all will be processed once and for each of them there will be an output from XI. Since they were fed into single queue INPUTQUEUE, there is a guarantee that the first 10 files (of 1st process) will be delivered first and then the 5 files (2nd file)
In both case the Read files need to be archived
Regards
Suraj
Edited by: S.R.Suraj on Sep 11, 2009 2:44 AM

Receiver FTP processing parameters should not add time stamp

Hi Gurus,
 I want to write the file at receiver end with the same name as in source directory.. (I dont want the time stamp to be added to my file at receiver side)
 For that i have configured processing parameters as
 1) File Construction mode --- create
 2) checked Overwrite existing file
 3) Put File -
use temporary file
 4) Temporary File Name Scheme --- rec_*.tmp
 5) File type -
binary
But the files are not written in target directory..
How to troubleshoot it...
Thanks and Regards,
govada.

Hi,
open RWB - coomponent monitoring
and then - adapter monitoring or communication channel monitoring
(depending on SP of your XI)
then find your channel and you will see the error - if there is any
BTW
if you don't want the timestamp just don't use:
Add Time Stamp property in the file adapter
Regards,
michal
<a href="/people/michal.krawczyk2/blog/2005/06/28/xipi-faq-frequently-asked-questions">XI / PI FAQ - Frequently Asked Questions</a>

Is there a way to monitor FTP processes?

Is there a console that can be used?

Hi,
Well i have my inmates working in BASIS services.Also i previously had an acces to it(training server)But now i dont .
Thats why i couldnt able to give your the tcode for that.But if u still what an help let me check for the same .

Help needed for file processing using FTP

Hi All,
I am new to ODI tool and currently we are implementing one project in ODI. Could you please, any one help me on the following requirement... how to implement it?
Scenario:
i) I need to pick a file from remote host 'outbox' dir using FTP process, and place into local 'temp' dir. (I can do it with odiFTPGet tool)
ii) Change the file as per target business requirement.??? ( this step challenging me)
for ex:
if source file name : <project name>_<source ID>_<transaction name>_<unique id>.txt
target name should be : 1234_<transaction name>_<sysdate in yyyyMMddhhmmss>_<unique id>_2345.txt ( here 1234 and 2345 are hard coded values)
iii) Later move to local 'temp' to local 'outbox' dir. ( I can do it with odiFileMove tool)
iv) After successful process move the file from remote 'outbox' to remote 'archive' dir ??? (again this is challenging me).
For this my questions are:
1) How to get file name into a variable ( In one of the post , it says we need to create data model and data stores, and interface to get the file names into a file. apart from is there any easy way i can implement it in package it self?)
2) How to tokenize a long string ( i.e., need to tokenize the source file to get <unique id> and <transaction name> and map to target file name)
3) How to define implementation for Java in user function?? do we need to use class declarations and import statements?? I need a sample user function in Java.
4) How to move/rename a file in remote server?? ( need to move file from remote 'outbox' server to remote archive' dir)
5) If any step in package fails, How to get the error msg into a variable which i can use for sending mail and raise a ticket in remedy?? ( I will pass that variable to as content to mail and remedy ticket)
6) How to handle list type data (string list) by variables in ODI?? (As we can define single variable not as list.)
I am sorry to ask all my queries I a single post. But I need to solutions for all to implement this in my project.
Thanks in advance. Appreciate early response.
Regards,
Kiran.N

Can any one share your thoughts for my request.
Thanks in advance.
Regards,
Kiran

How to configure FTP in Process Flow

I'm having troubles configuring an FTP activity in my process flow. Any clue how that should be done?
The documentation does not tell that much. I added the following to my parameter list in "Activity Panel"
/${Working.Host}=100.1.15.236/${Working.User}=XYZ/${Working.Password}=xxxxx/${Working.Rootpath}=C:\Nova\Data/${Remote.Host}=192.168.100.100/${Remote.User}=oracle/${Remote.Password}=xxxxx/${Remote.RootPath}=/export/home/oracle/
where "/" is the variable delimiter. The deployment went successfully, but when I try to execute, it hangs at the FTP activity and generate an error when cancelled.
Any help will be appreciated
Thanks,
Rene

URGENT!!!
i have included FTP activity in my process flow, i can able to FTP the file to the remote server.
I have two transitions and point to two end processes, one is end-success and the other one is end-error. But even if the FTP process completed and file have been successfully send to the remote server, still the process ends with End-Error.
If the FTP activity couldnt able to send the file due to some other reason still the process ends with the end-error.
Can any one give me some clues.

If you need to FTP with PL/SQL...

If you need to perform FTP from within PL/SQL and your database version has the UTL_TCP package, here is a free package you can use. The source code is hopefully documented well enough for you to tell what's going on and how to use the functions. Suggestions on improving the code are welcome, and I can provide limited support via email for what I've written, but I would encourage anyone who uses the code to modify/fix it according to their needs. If you modify the code, I respectfully request that you leave intact the authorship and note comments at the beginning of the package.
Please note that I have not rigorously tested this code, but it has successfully transferred files in both directions in the limited tests that I have performed.
-- Copy the code below and run it in your favorite SQL editor --
CREATE OR REPLACE PACKAGE FTP IS
Simplified FTP client API using UTL_TCP package
Author: Alan Wessman, Brigham Young University
Note: This FTP client attempts to adhere to the protocol and advice found at:
http://cr.yp.to/ftp.html
No warranties are made regarding the correctness of this code.
Notes:
1. Most of these functions will raise UTL_TCP.NETWORK_ERROR if the connection
is not open or is reset during the network transaction. They will also
raise VALUE_ERROR if the server response is ill-formed or a buffer is
too small to hold data. (Most buffers in this package are defined as
VARCHAR2(32767) to avoid size limitations; reduce this if memory overhead
is a concern.)
2. "Verbose mode" can be enabled/disabled by changing the default value of
the vDebug variable in the package body. Setting vDebug to TRUE will
cause a session transcript to be output to DBMS_OUTPUT.
3. The following is an example of how this package might be used:
declare
c utl_tcp.connection;
vresp varchar2(32767);
vbuf varchar2(32767);
vresp_code number;
vremote_host varchar2(32) := 'some.hostname.com';
vusername varchar2(8) := 'username';
vpassword varchar2(8) := 'password';
begin
dbms_output.put_line( 'Opening session...' );
vresp_code := ftp.open_session( c,
vremote_host,
vusername,
vpassword,
vresp,
5 );
vresp_code := ftp.put( c,
'/home/somebody',
'local.test',
'remote.test',
vresp );
vresp_code := ftp.remote_command( c, 'CHMOD 660 remote.test' );
vresp_code := ftp.chdir( c, '/home/somebody/subdir' );
vresp_code := ftp.pwd( c );
vresp_code := ftp.get( c,
'/home/somebody',
'new_file.test',
'another_remote_file.test',
vresp );
vresp_code := ftp.close_session( c );
dbms_output.put_line( 'Closed session.' );
exception
when others then dbms_output.put_line( sqlcode || ':' || sqlerrm );
end;
Function: Open_Session
Description: Begins an FTP session with the remote server.
Parameters:
conn OUT parameter that contains the connection info; to be passed
in to subsequent commands to maintain session state.
host Name or IP address of remote server
username User ID to use for login
password Password to use for login
response OUT parameter; buffer for server replies
timeout_secs Number of seconds for TCP timeout. Pass in NULL to disable
timeout (wait forever for responses). Pass in 0 (zero) for
no wait.
Return value: 0 (zero) if operation is successful; FTP error code if operation
is not successful.
Exceptions: May raise UTL_TCP.NETWORK_ERROR if host parameter is incorrect or if
some other networking error occurs.
May raise VALUE_ERROR if server response is ill-formed.
FUNCTION Open_Session( conn OUT NOCOPY UTL_TCP.Connection,
host IN VARCHAR2,
username IN VARCHAR2,
password IN VARCHAR2,
response OUT VARCHAR2,
timeout_secs IN NUMBER DEFAULT 60 ) RETURN NUMBER;
Function: Get
Description: Retrieves a file on the remote server and stores its contents in
a VARCHAR2 buffer.
Parameters:
conn IN OUT parameter that contains the connection info; to be
passed in to subsequent commands to maintain session state.
buf OUT parameter; buffer for retrieved file contents
remote_path Pathname (including file name) indicating location of remote
file to be retrieved
response OUT parameter; buffer for server replies.
Return value: 0 (zero) if operation is successful; FTP error code if operation
is not successful.
Exceptions: May raise UTL_TCP.NETWORK_ERROR if some networking error occurs.
May raise VALUE_ERROR if server response is ill-formed or buf is
too small for file contents.
FUNCTION Get( conn IN OUT NOCOPY UTL_TCP.Connection,
buf OUT VARCHAR2,
remote_path IN VARCHAR2,
response OUT VARCHAR2 ) RETURN NUMBER;
Function: Get
Description: Retrieves a file on the remote server and stores its contents in
a local file. Assumes an open file handle and does not close it.
Parameters:
conn IN OUT parameter that contains the connection info; to be
passed in to subsequent commands to maintain session state.
local_file IN OUT parameter; UTL_FILE file handle for input file. File
is assumed to be open for writing.
remote_path Pathname (including file name) indicating location of remote
file to be retrieved
response OUT parameter; buffer for server replies.
Return value: 0 (zero) if operation is successful; FTP error code if operation
is not successful.
Exceptions: May raise UTL_TCP.NETWORK_ERROR if some networking error occurs.
May raise VALUE_ERROR if server response is ill-formed or buf is
too small for file contents.
May raise any of the UTL_FILE exceptions if file write operations
fail. See UTL_FILE documentation for additional details.
FUNCTION Get( conn IN OUT NOCOPY UTL_TCP.Connection,
local_file IN OUT UTL_FILE.File_Type,
remote_path IN VARCHAR2,
response OUT VARCHAR2 ) RETURN NUMBER;
Function: Get
Description: Retrieves a file on the remote server and stores its contents in
a local file. Opens and closes local file automatically.
Parameters:
conn IN OUT parameter that contains the connection info; to be
passed in to subsequent commands to maintain session state.
local_path Pathname of local directory in which to store the retrieved
file's contents
local_filename Name of local file in which to store retrieved file's contents
(creates new file or overwrites existing file)
remote_path Pathname (including file name) indicating location of remote
file to be retrieved
response OUT parameter; buffer for server replies.
Return value: 0 (zero) if operation is successful; FTP error code if operation
is not successful.
Exceptions: May raise UTL_TCP.NETWORK_ERROR if some networking error occurs.
May raise VALUE_ERROR if server response is ill-formed or buf is
too small for file contents.
May raise any of the UTL_FILE exceptions if file open, write, or
close operations fail. See UTL_FILE documentation for additional
details.
FUNCTION Get( conn IN OUT NOCOPY UTL_TCP.Connection,
local_path IN VARCHAR2,
local_filename IN VARCHAR2,
remote_path IN VARCHAR2,
response OUT VARCHAR2 ) RETURN NUMBER;
Function: Put
Description: Stores data as a file on the remote server
Parameters:
conn IN OUT parameter that contains the connection info; to be
passed in to subsequent commands to maintain session state.
buf IN parameter; contains data to upload
remote_path Pathname (including file name) indicating location of remote
file to be created/overwritten
response OUT parameter; buffer for server replies.
Return value: 0 (zero) if operation is successful; FTP error code if operation
is not successful.
Exceptions: May raise UTL_TCP.NETWORK_ERROR if some networking error occurs.
May raise VALUE_ERROR if server response is ill-formed.
FUNCTION Put( conn IN OUT NOCOPY UTL_TCP.Connection,
buf IN VARCHAR2,
remote_path IN VARCHAR2,
response OUT VARCHAR2 ) RETURN NUMBER;
Function: Put
Description: Uploads a local file to the remote server. Assumes an open file
handle and does not close it.
Parameters:
conn IN OUT parameter that contains the connection info; to be
passed in to subsequent commands to maintain session state.
local_file IN OUT parameter; UTL_FILE file handle for input file. File
is assumed to be open for reading.
remote_path Pathname (including file name) indicating location of remote
file to be created/overwritten.
response OUT parameter; buffer for server replies.
Return value: 0 (zero) if operation is successful; FTP error code if operation
is not successful.
Exceptions: May raise UTL_TCP.NETWORK_ERROR if some networking error occurs.
May raise VALUE_ERROR if server response is ill-formed.
May raise any of the UTL_FILE exceptions if file read operations
fail. See UTL_FILE documentation for additional details.
FUNCTION Put( conn IN OUT NOCOPY UTL_TCP.Connection,
local_file IN OUT UTL_FILE.File_Type,
remote_path IN VARCHAR2,
response OUT VARCHAR2 ) RETURN NUMBER;
Function: Put
Description: Uploads a local file to the remote server. Opens and closes local
file automatically.
Parameters:
conn IN OUT parameter that contains the connection info; to be
passed in to subsequent commands to maintain session state.
local_path Pathname of local directory in which file to upload exists.
local_filename Name of local file to upload.
remote_path Pathname (including file name) indicating location of remote
file to be created/overwritten.
response OUT parameter; buffer for server replies.
Return value: 0 (zero) if operation is successful; FTP error code if operation
is not successful.
Exceptions: May raise UTL_TCP.NETWORK_ERROR if some networking error occurs.
May raise VALUE_ERROR if server response is ill-formed.
May raise any of the UTL_FILE exceptions if file open, read, or
close operations fail. See UTL_FILE documentation for additional
details.
FUNCTION Put( conn IN OUT NOCOPY UTL_TCP.Connection,
local_path IN VARCHAR2,
local_filename IN VARCHAR2,
remote_path IN VARCHAR2,
response OUT VARCHAR2 ) RETURN NUMBER;
Function: Remote_Command
Description: Sends an arbitrary command to the server via the SITE command.
Parameters:
conn IN OUT parameter that contains the connection info; to be
passed in to subsequent commands to maintain session state.
command Command and parameter(s) to send to the server, e.g.
'CHMOD 600 foo.txt'
Return value: 0 (zero) if operation is successful; FTP error code if operation
is not successful.
Exceptions: May raise UTL_TCP.NETWORK_ERROR if some networking error occurs.
May raise VALUE_ERROR if server response is ill-formed.
FUNCTION Remote_Command( conn IN OUT NOCOPY UTL_TCP.Connection,
command IN VARCHAR2 ) RETURN NUMBER;
Function: Chdir
Description: Changes current working directory on remote server to specified
path.
Parameters:
conn IN OUT parameter that contains the connection info; to be
passed in to subsequent commands to maintain session state.
remote_path Path on remote server to change to.
Return value: 0 (zero) if operation is successful; FTP error code if operation
is not successful.
Exceptions: May raise UTL_TCP.NETWORK_ERROR if some networking error occurs.
May raise VALUE_ERROR if server response is ill-formed.
FUNCTION Chdir( conn IN OUT NOCOPY UTL_TCP.Connection,
remote_path IN VARCHAR2 ) RETURN NUMBER;
Function: Pwd
Description: Prints current working directory (on remote server) to debugging
output if debugging is turned on.
Parameters:
conn IN OUT parameter that contains the connection info; to be
passed in to subsequent commands to maintain session state.
Return value: 0 (zero) if operation is successful; FTP error code if operation
is not successful.
Exceptions: May raise UTL_TCP.NETWORK_ERROR if some networking error occurs.
May raise VALUE_ERROR if server response is ill-formed.
FUNCTION Pwd( conn IN OUT NOCOPY UTL_TCP.Connection ) RETURN NUMBER;
Function: Close_Session
Description: Closes the TCP connection to the remote server.
Parameters:
conn IN OUT parameter that contains the connection info; to be
passed in to subsequent commands to maintain session state.
Return value: 0 (zero)
Exceptions: None raised.
FUNCTION Close_Session( conn IN OUT NOCOPY UTL_TCP.Connection ) RETURN NUMBER;
Function: Close_All_Sessions
Description: Closes all currently open TCP connections.
Parameters: None.
Return value: 0 (zero)
Exceptions: None raised.
FUNCTION Close_All_Sessions RETURN NUMBER;
END FTP;
CREATE OR REPLACE PACKAGE BODY FTP IS
vDebug BOOLEAN := TRUE;
FATAL_ERROR EXCEPTION;
PROCEDURE Debug( msg IN VARCHAR2 ) IS
BEGIN
IF vDebug THEN
DBMS_OUTPUT.Put_Line( msg );
END IF;
END Debug;
FUNCTION Get_Response( conn IN OUT NOCOPY UTL_TCP.Connection,
buf IN OUT VARCHAR2 ) RETURN NUMBER IS
vLen NUMBER;
vCode NUMBER;
vResp VARCHAR2(32767);
BEGIN
vLen := UTL_TCP.READ_LINE( conn, vResp );
Debug( vResp );
-- If TO_NUMBER below fails, let the exception propagate to calling proc
vCode := TO_NUMBER( SUBSTR( vResp, 1, 3 ) );
vResp := SUBSTR( vResp, 4 );
buf := buf || SUBSTR( vResp, 2 );
IF SUBSTR( vResp, 1, 1 ) = '-' THEN
LOOP
vLen := UTL_TCP.READ_LINE( conn, vResp );
Debug( vResp );
<<Get_Code>>
BEGIN
vCode := TO_NUMBER( SUBSTR( vResp, 1, 3 ) );
vResp := SUBSTR( vResp, 4 );
IF SUBSTR( vResp, 1, 1 ) = ' ' THEN
buf := buf || SUBSTR( vResp, 2 );
EXIT;
END IF;
EXCEPTION WHEN VALUE_ERROR THEN NULL;
END Get_Code;
buf := buf || vResp;
END LOOP;
END IF;
RETURN vCode;
END Get_Response;
FUNCTION Do_Command( conn IN OUT NOCOPY UTL_TCP.Connection,
cmd IN VARCHAR2,
response OUT VARCHAR2 ) RETURN NUMBER IS
vResult NUMBER := 0;
BEGIN
vResult := UTL_TCP.WRITE_LINE( conn, cmd );
vResult := Get_Response( conn, response );
RETURN vResult;
END Do_Command;
FUNCTION Parse_Port_Number( port_string IN VARCHAR2 ) RETURN NUMBER IS
vResult NUMBER;
vNew_Port_String VARCHAR2(32767);
BEGIN
-- This stuff parses out the port number encoding from the server reply
-- Reply is in the format xyzh1,h2,h3,h4,p1,p2xyz
-- xyz = possible character data (server-dependent, may not exist)
-- h1-h4 = server IP elements; ignore since we know the host already
-- p1,p2 = port number encoding (port number = p1 * 256 + p2 )
vNew_Port_String := TRANSLATE( port_string, '0123456789', '0000000000' );
vNew_Port_String := SUBSTR( port_string,
INSTR( vNew_Port_String, '0' ),
INSTR( vNew_Port_String, '0', -1 ) -
INSTR( vNew_Port_String, '0' ) + 1 );
vNew_Port_String := SUBSTR( vNew_Port_String,
INSTR( vNew_Port_String, ',', 1, 4 ) + 1 );
vResult := 256 * TO_NUMBER( SUBSTR( vNew_Port_String,
1,
INSTR( vNew_Port_String, ',' ) - 1 ) );
vResult := vResult + TO_NUMBER( SUBSTR( vNew_Port_String,
INSTR( vNew_Port_String, ',' ) + 1 ) );
RETURN vResult;
-- Allow VALUE_ERROR to propagate
END Parse_Port_Number;
FUNCTION Open_Session( conn OUT NOCOPY UTL_TCP.Connection,
host IN VARCHAR2,
username IN VARCHAR2,
password IN VARCHAR2,
response OUT VARCHAR2,
timeout_secs IN NUMBER DEFAULT 60 ) RETURN NUMBER IS
vResp_Code NUMBER;
vGarbage NUMBER; -- For calling functions when we don't care about return val
BEGIN
conn := UTL_TCP.OPEN_CONNECTION( host,
21,
tx_timeout => timeout_secs );
vResp_Code := Get_Response( conn, response );
IF vResp_Code = 220 THEN
vResp_Code := Do_Command( conn, 'USER ' || username, response );
IF vResp_Code IN ( 331, 332 ) THEN
vResp_Code := Do_Command( conn, 'PASS ' || password, response );
IF vResp_Code NOT IN ( 202, 230 ) THEN
RAISE FATAL_ERROR;
END IF;
ELSE
RAISE FATAL_ERROR;
END IF;
END IF;
vResp_Code := Do_Command( conn, 'TYPE I', response );
Debug( 'Logged into ' || conn.remote_host || ' at port ' || conn.remote_port );
RETURN 0;
EXCEPTION
WHEN FATAL_ERROR THEN
Debug( 'Fatal error opening session:' );
Debug( ' Code: ' || vResp_Code );
Debug( ' Response: ' || response );
vGarbage := Close_Session( conn );
RETURN vResp_Code;
END Open_Session;
FUNCTION Get( conn IN OUT NOCOPY UTL_TCP.Connection,
buf OUT VARCHAR2,
remote_path IN VARCHAR2,
response OUT VARCHAR2 ) RETURN NUMBER IS
vResp VARCHAR2(32767);
vResp_Code NUMBER;
vNew_Conn UTL_TCP.Connection;
vNew_Port NUMBER;
BEGIN
-- do PASV
vResp_Code := Do_Command( conn, 'PASV', response );
IF vResp_Code = 227 THEN
<<Switch_Port>>
BEGIN
vNew_Port := Parse_Port_Number( response );
vNew_Conn := UTL_TCP.OPEN_CONNECTION( conn.remote_host,
vNew_Port,
tx_timeout => conn.tx_timeout );
Debug( 'Data connection: ' || vNew_Conn.remote_host || ':' || vNew_Conn.remote_port );
vResp_Code := Do_Command( conn, 'RETR ' || REPLACE( remote_path, CHR(12), CHR(0) ), response );
IF vResp_Code <> 150 THEN
RAISE FATAL_ERROR;
END IF;
<<Get_Download>>
BEGIN
LOOP
vResp := vResp || UTL_TCP.GET_LINE( vNew_Conn, FALSE );
END LOOP;
EXCEPTION
WHEN UTL_TCP.END_OF_INPUT THEN NULL;
END Get_Download;
vResp_Code := Close_Session( vNew_Conn );
vResp_Code := Get_Response( conn, response );
IF vResp_Code BETWEEN 400 AND 599 THEN
RAISE FATAL_ERROR;
END IF;
EXCEPTION
WHEN OTHERS THEN
Debug( SQLERRM );
RAISE FATAL_ERROR;
END Switch_Port;
ELSE
RAISE FATAL_ERROR;
END IF;
vResp_Code := Close_Session( vNew_Conn );
buf := vResp;
RETURN 0;
EXCEPTION
WHEN FATAL_ERROR THEN
Debug( 'Fatal error getting ' || remote_path || ':' );
Debug( ' Code: ' || vResp_Code );
Debug( ' Response: ' || response );
vResp_Code := Close_Session( vNew_Conn );
RETURN vResp_Code;
WHEN OTHERS THEN
Debug( vResp_Code || ': ' || SQLERRM );
RETURN vResp_Code;
END Get;
FUNCTION Get( conn IN OUT NOCOPY UTL_TCP.Connection,
local_file IN OUT UTL_FILE.File_Type,
remote_path IN VARCHAR2,
response OUT VARCHAR2 ) RETURN NUMBER IS
vResp VARCHAR2(32767);
vResp_Code NUMBER := -1;
vNew_Conn UTL_TCP.Connection;
vNew_Port NUMBER;
BEGIN
-- do PASV
vResp_Code := Do_Command( conn, 'PASV', response );
IF vResp_Code = 227 THEN
<<Switch_Port>>
BEGIN
vNew_Port := Parse_Port_Number( response );
vNew_Conn := UTL_TCP.OPEN_CONNECTION( conn.remote_host,
vNew_Port,
tx_timeout => conn.tx_timeout );
Debug( 'Data connection: ' || vNew_Conn.remote_host || ':' || vNew_Conn.remote_port );
vResp_Code := Do_Command( conn, 'RETR ' || REPLACE( remote_path, CHR(12), CHR(0) ), response );
IF vResp_Code <> 150 THEN
RAISE FATAL_ERROR;
END IF;
<<Get_Download>>
BEGIN
LOOP
vResp := UTL_TCP.GET_LINE( vNew_Conn, FALSE );
UTL_FILE.Put( local_file, vResp );
END LOOP;
EXCEPTION
WHEN UTL_TCP.END_OF_INPUT THEN NULL;
END Get_Download;
vResp_Code := Close_Session( vNew_Conn );
vResp_Code := Get_Response( conn, response );
IF vResp_Code BETWEEN 400 AND 599 THEN
RAISE FATAL_ERROR;
END IF;
EXCEPTION
WHEN OTHERS THEN
Debug( SQLERRM );
RAISE FATAL_ERROR;
END Switch_Port;
ELSE
RAISE FATAL_ERROR;
END IF;
vResp_Code := Close_Session( vNew_Conn );
RETURN 0;
EXCEPTION
WHEN FATAL_ERROR THEN
Debug( 'Fatal error getting ' || remote_path || ':' );
Debug( ' Code: ' || vResp_Code );
Debug( ' Response: ' || response );
vResp_Code := Close_Session( vNew_Conn );
RETURN vResp_Code;
WHEN OTHERS THEN
Debug( vResp_Code || ': ' || SQLERRM );
RETURN vResp_Code;
END Get;
FUNCTION Get( conn IN OUT NOCOPY UTL_TCP.Connection,
local_path IN VARCHAR2,
local_filename IN VARCHAR2,
remote_path IN VARCHAR2,
response OUT VARCHAR2 ) RETURN NUMBER IS
vFile UTL_FILE.File_Type;
vResult NUMBER := -1;
BEGIN
vFile := UTL_FILE.FOPEN( local_path, local_filename, 'w' );
vResult := Get( conn, vFile, remote_path, response );
UTL_FILE.FCLOSE( vFile );
RETURN vResult;
EXCEPTION WHEN OTHERS THEN
IF UTL_FILE.IS_OPEN( vFile ) THEN
UTL_FILE.FCLOSE( vFile );
END IF;
RAISE;
END Get;
FUNCTION Put( conn IN OUT NOCOPY UTL_TCP.Connection,
buf IN VARCHAR2,
remote_path IN VARCHAR2,
response OUT VARCHAR2 ) RETURN NUMBER IS
vResp VARCHAR2(32767);
vResp_Code NUMBER;
vNew_Conn UTL_TCP.Connection;
vNew_Port NUMBER;
BEGIN
-- do PASV
vResp_Code := Do_Command( conn, 'PASV', response );
IF vResp_Code = 227 THEN
<<Switch_Port>>
BEGIN
vNew_Port := Parse_Port_Number( response );
vNew_Conn := UTL_TCP.OPEN_CONNECTION( conn.remote_host,
vNew_Port,
tx_timeout => conn.tx_timeout );
Debug( 'Data connection: ' || vNew_Conn.remote_host || ':' || vNew_Conn.remote_port );
vResp_Code := Do_Command( conn, 'STOR ' || REPLACE( remote_path, CHR(12), CHR(0) ), response );
IF vResp_Code <> 150 THEN
RAISE FATAL_ERROR;
END IF;
vResp_Code := UTL_TCP.WRITE_TEXT( vNew_Conn, buf );
UTL_TCP.FLUSH( vNew_Conn );
vResp_Code := Close_Session( vNew_Conn );
vResp_Code := Get_Response( conn, response );
IF vResp_Code BETWEEN 400 AND 599 THEN
RAISE FATAL_ERROR;
END IF;
EXCEPTION
WHEN OTHERS THEN
Debug( SQLERRM );
RAISE FATAL_ERROR;
END Switch_Port;
ELSE
RAISE FATAL_ERROR;
END IF;
vResp_Code := Close_Session( vNew_Conn );
response := vResp;
RETURN 0;
EXCEPTION
WHEN FATAL_ERROR THEN
Debug( 'Fatal error putting ' || remote_path || ':' );
Debug( ' Code: ' || vResp_Code );
Debug( ' Response: ' || response );
vResp_Code := Close_Session( vNew_Conn );
RETURN vResp_Code;
WHEN OTHERS THEN
Debug( vResp_Code || ': ' || SQLERRM );
RETURN vResp_Code;
END Put;
FUNCTION Put( conn IN OUT NOCOPY UTL_TCP.Connection,
local_file IN OUT UTL_FILE.File_Type,
remote_path IN VARCHAR2,
response OUT VARCHAR2 ) RETURN NUMBER IS
vResp VARCHAR2(32767);
vResp_Code NUMBER;
vNew_Conn UTL_TCP.Connection;
vNew_Port NUMBER;
vNew_Port_String VARCHAR2(32767);
BEGIN
-- do PASV
vResp_Code := Do_Command( conn, 'PASV', response );
IF vResp_Code = 227 THEN
<<Switch_Port>>
BEGIN
vNew_Port := Parse_Port_Number( response );
vNew_Conn := UTL_TCP.OPEN_CONNECTION( conn.remote_host,
vNew_Port,
tx_timeout => conn.tx_timeout );
Debug( 'Data connection: ' || vNew_Conn.remote_host || ':' || vNew_Conn.remote_port );
vResp_Code := Do_Command( conn, 'STOR ' || REPLACE( remote_path, CHR(12), CHR(0) ), response );
IF vResp_Code <> 150 THEN
RAISE FATAL_ERROR;
END IF;
<<Get_Download>>
BEGIN
LOOP
UTL_FILE.Get_Line( local_file, vResp );
vResp_Code := UTL_TCP.WRITE_LINE( vNew_Conn, vResp );
END LOOP;
EXCEPTION
WHEN NO_DATA_FOUND THEN NULL;
END Get_Download;
vResp_Code := Close_Session( vNew_Conn );
vResp_Code := Get_Response( conn, response );
IF vResp_Code BETWEEN 400 AND 599 THEN
RAISE FATAL_ERROR;
END IF;
EXCEPTION
WHEN OTHERS THEN
Debug( SQLERRM );
RAISE FATAL_ERROR;
END Switch_Port;
ELSE
RAISE FATAL_ERROR;
END IF;
vResp_Code := Close_Session( vNew_Conn );
RETURN 0;
EXCEPTION
WHEN FATAL_ERROR THEN
Debug( 'Fatal error putting ' || remote_path || ':' );
Debug( ' Code: ' || vResp_Code );
Debug( ' Response: ' || response );
vResp_Code := Close_Session( vNew_Conn );
RETURN vResp_Code;
WHEN OTHERS THEN
Debug( vResp_Code || ': ' || SQLERRM );
RETURN vResp_Code;
END Put;
FUNCTION Put( conn IN OUT NOCOPY UTL_TCP.Connection,
local_path IN VARCHAR2,
local_filename IN VARCHAR2,
remote_path IN VARCHAR2,
response OUT VARCHAR2 ) RETURN NUMBER IS
vFile UTL_FILE.File_Type;
vResult NUMBER;
BEGIN
vFile := UTL_FILE.FOPEN( local_path, local_filename, 'r' );
vResult := Put( conn, vFile, remote_path, response );
UTL_FILE.FCLOSE( vFile );
RETURN vResult;
EXCEPTION WHEN OTHERS THEN
IF UTL_FILE.IS_OPEN( vFile ) THEN
UTL_FILE.FCLOSE( vFile );
END IF;
RAISE;
END Put;
FUNCTION Remote_Command( conn IN OUT NOCOPY UTL_TCP.Connection,
command IN VARCHAR2 ) RETURN NUMBER IS
vResp_Code NUMBER;
vResponse VARCHAR2(32767);
BEGIN
vResp_Code := Do_Command( conn, 'SITE ' || command, vResponse );
IF vResp_Code BETWEEN 500 AND 599 THEN
RETURN vResp_Code;
END IF;
RETURN 0;
END Remote_Command;
FUNCTION Chdir( conn IN OUT NOCOPY UTL_TCP.Connection,
remote_path IN VARCHAR2 ) RETURN NUMBER IS
vResp_Code NUMBER;
vResponse VARCHAR2(32767);
BEGIN
vResp_Code := Do_Command( conn, 'CWD ' || REPLACE( remote_path, CHR(12), CHR(0) ), vResponse );
IF vResp_Code BETWEEN 500 AND 599 THEN
RETURN vResp_Code;
END IF;
RETURN 0;
END Chdir;
FUNCTION Pwd( conn IN OUT NOCOPY UTL_TCP.Connection ) RETURN NUMBER IS
vResp_Code NUMBER;
vResponse VARCHAR2(32767);
BEGIN
vResp_Code := Do_Command( conn, 'PWD', vResponse );
IF vResp_Code BETWEEN 500 AND 599 THEN
RETURN vResp_Code;
END IF;
RETURN 0;
END Pwd;
FUNCTION Close_Session( conn IN OUT NOCOPY UTL_TCP.Connection ) RETURN NUMBER IS
BEGIN
IF conn.remote_host IS NULL THEN
RETURN 0;
END IF;
Debug( 'Closing connection on ' || conn.remote_host || ':' || conn.remote_port );
UTL_TCP.Close_Connection( conn );
RETURN 0;
EXCEPTION
WHEN UTL_TCP.NETWORK_ERROR THEN RETURN 0;
END Close_Session;
FUNCTION Close_All_Sessions RETURN NUMBER IS
BEGIN
UTL_TCP.Close_All_Connections;
RETURN 0;
END Close_All_Sessions;
END FTP;

Here's another PL/SQL package that will FTP ASCII text files. It assumes that you have proper permissions on the remote host and simply want to transfer one or more text files, not perform any other miscellaneous commands.
Also, from what I have read, in 9i UTL_FILE supports reading and writing of binary data so an FTP client could be written to transfer either ASCII or BINARY files.
Regards,
Russ
CREATE OR REPLACE PACKAGE BRNC_FTP_PKG
AS
* PL/SQL FTP Client
* Created by: Russ Johnson, Braun Consulting
* www.braunconsult.com
* OVERVIEW
* This package uses the standard packages UTL_FILE and UTL_TCP to perform
* client-side FTP functionality (PUT and GET) for text files as defined in
* the World Wide Web Consortium's RFC 959 document - http://www.w3.org/Protocols/rfc959/
* The procedures and functions in this package allow single or multiple file transfer using
* standard TCP/IP connections.
* LIMITATIONS
* Currently the API is limited to transfer of ASCII text files only. This is
* primarily because UTL_FILE only supports text I/O, but also because the original
* design was for creating text files from data in the Oracle database, then transferring the file to a remote host.
* Furthermore, the API does not support SSH/Secure FTP or connection through a proxy server.
* Keep in mind that FTP passes the username/password combo in plain text over TCP/IP.
* DB versions - 8i (8.1.x) and above. 8.0.x may work if it has the SYS.UTL_TCP package.
* Note: Since UTL_FILE is used for the client-side I/O, this package is also limited to
* transfer of files that exist in directories available to UTL_FILE for read/write.
* These directories are defined by the UTL_FILE_DIR parameter in the init.ora file.
* USAGE
* Three functions are available for FTP - PUT, GET, and FTP_MULTIPLE. FTP_MULTIPLE takes
* a table of records that define the files to be transferred (filename, directory, etc.).
* That table can have 1 record or multiple records. The PUT and GET functions are included
* for convenience to FTP one file at a time. PUT and GET return true if the file is transferred
* successfully and false if it fails. FTP_MULTIPLE returns true if no batch-level errors occur
* (such as an invalid host, refused connection, or invalid login information). It also takes the
* table of file records IN and passes it back OUT. Each record contains individual error information.
* EXAMPLE
* Transfer multiple files - 1 GET and 2 PUT from a Windows machine to a host (assuming UNIX here).
* Display any errors that occur.
* DECLARE
* v_username VARCHAR2(40) := 'rjohnson';
* v_password VARCHAR2(40) := 'password';
* v_hostname VARCHAR2(255) := 'ftp.oracle.com';
* v_error_message VARCHAR2(1000);
* b_put BOOLEAN;
* t_files BRNC_FTP_PKG.t_ftp_rec; -- Declare our table of file records
* BEGIN
* t_files(1).localpath := 'd:\oracle\utl_file\outbound';
* t_files(1).filename := 'myfile1.txt';
* t_files(1).remotepath := '/home/oracle/text_files';
* t_files(1).transfer_mode := 'PUT';
* t_files(2).localpath := 'd:\oracle\utl_file\inbound';
* t_files(2).filename := 'incoming_file.xml';
* t_files(2).remotepath := '/home/oracle/xml_files';
* t_files(2).transfer_mode := 'GET';
* t_files(3).localpath := 'd:\oracle\utl_file\outbound';
* t_files(3).filename := 'myfile2.txt';
* t_files(3).remotepath := '/home';
* t_files(3).transfer_mode := 'PUT';
* b_put := BRNC_FTP_PKG.FTP_MULTIPLE(v_error_message,
* t_files,
* v_username,
* v_password,
* v_hostname);
* IF b_put = TRUE
* THEN
* FOR i IN t_files.FIRST..t_files.LAST
* LOOP
* IF t_files.EXISTS(i)
* THEN
* DBMS_OUTPUT.PUT_LINE(t_files(i).status||' | '||
* t_files(i).error_message||' | '||
* to_char(t_files(i).bytes_transmitted)||' | '||
* to_char(t_files(i).trans_start,'YYYY-MM-DD HH:MI:SS')||' | '||
* to_char(t_files(i).trans_end,'YYYY-MM-DD HH:MI:SS'));
* END IF;
* END LOOP;
* ELSE
* DBMS_OUTPUT.PUT_LINE(v_error_message);
* END IF;
* EXCEPTION
* WHEN OTHERS
* THEN
* DBMS_OUTPUT.PUT_LINE(SQLERRM);
* END;
* CREDITS
* The W3C's RFC 959 that describes the FTP process.
* http://www.w3c.org
* Much of the PL/SQL code in this package was based on Java code written by
* Bruce Blackshaw of Enterprise Distributed Technologies Ltd. None of that code
* was copied, but the objects and methods greatly helped my understanding of the
* FTP Client process.
* http://www.enterprisedt.com
* VERSION HISTORY
* 1.0 11/19/2002 Unit-tested single and multiple transfers between disparate hosts.
* Exceptions
ctrl_exception EXCEPTION;
data_exception EXCEPTION;
* Constants - FTP valid response codes
CONNECT_CODE CONSTANT PLS_INTEGER := 220;
USER_CODE CONSTANT PLS_INTEGER := 331;
LOGIN_CODE CONSTANT PLS_INTEGER := 230;
PWD_CODE CONSTANT PLS_INTEGER := 257;
PASV_CODE CONSTANT PLS_INTEGER := 227;
CWD_CODE CONSTANT PLS_INTEGER := 250;
TSFR_START_CODE1 CONSTANT PLS_INTEGER := 125;
TSFR_START_CODE2 CONSTANT PLS_INTEGER := 150;
TSFR_END_CODE CONSTANT PLS_INTEGER := 226;
QUIT_CODE CONSTANT PLS_INTEGER := 221;
SYST_CODE CONSTANT PLS_INTEGER := 215;
TYPE_CODE CONSTANT PLS_INTEGER := 200;
* FTP File record datatype
* Elements:
* localpath - full directory name in which the local file resides or will reside
* Windows: 'd:\oracle\utl_file'
* UNIX: '/home/oracle/utl_file'
* filename - filename and extension for the file to be received or sent
* changing the filename for the PUT or GET is currently not allowed
* Examples: 'myfile.dat' 'myfile20021119.xml'
* remotepath - full directory name in which the local file will be sent or the
* remote file exists. Should be in UNIX format regardless of FTP server - '/one/two/three'
* filetype - reserved for future use, ignored in code
* transfer_mode - 'PUT' or 'GET'
* status - status of the transfer. 'ERROR' or 'SUCCESS'
* error_message - meaningful (hopefully) error message explaining the reason for failure
* bytes_transmitted - how many bytes were sent/received
* trans_start - date/time the transmission started
* trans_end - date/time the transmission ended
TYPE r_ftp_rec IS RECORD(localpath VARCHAR2(255),
 filename VARCHAR2(255),
 remotepath VARCHAR2(255),
 filetype VARCHAR2(20),
 transfer_mode VARCHAR2(5),
 status VARCHAR2(40),
 error_message VARCHAR2(255),
 bytes_transmitted NUMBER,
 trans_start DATE,
 trans_end DATE);
* FTP File Table - used to store many files for transfer
TYPE t_ftp_rec IS TABLE of r_ftp_rec INDEX BY BINARY_INTEGER;
* Internal convenience procedure for creating passive host IP address
* and port number.
PROCEDURE CREATE_PASV(p_pasv_cmd IN VARCHAR2,
 p_pasv_host OUT VARCHAR2,
 p_pasv_port OUT NUMBER);
* Function used to validate FTP server responses based on the
* code passed in p_code. Reads single or multi-line responses.
FUNCTION VALIDATE_REPLY(p_ctrl_con IN OUT UTL_TCP.CONNECTION,
 p_code IN PLS_INTEGER,
 p_reply OUT VARCHAR2)
 RETURN BOOLEAN;
* Function used to validate FTP server responses based on the
* code passed in p_code. Reads single or multi-line responses.
* Overloaded because some responses can have 2 valid codes.
FUNCTION VALIDATE_REPLY(p_ctrl_con IN OUT UTL_TCP.CONNECTION,
 p_code1 IN PLS_INTEGER,
 p_code2 IN PLS_INTEGER,
 p_reply OUT VARCHAR2)
 RETURN BOOLEAN;
* Procedure that handles the actual data transfer. Meant
* for internal package use. Returns information about the
* actual transfer.
PROCEDURE TRANSFER_ASCII(u_ctrl_con IN OUT UTL_TCP.CONNECTION,
 p_localpath IN VARCHAR2,
 p_filename IN VARCHAR2,
 p_pasv_host IN VARCHAR2,
 p_pasv_port IN PLS_INTEGER,
 p_transfer_mode IN VARCHAR2,
 v_status OUT VARCHAR2,
 v_error_message OUT VARCHAR2,
 n_bytes_transmitted OUT NUMBER,
 d_trans_start OUT DATE,
d_trans_end OUT DATE);
* Function to handle FTP of many files.
* Returns TRUE if no batch-level errors occur.
* Returns FALSE if a batch-level error occurs.
* Parameters:
* p_error_msg - error message for batch level errors
* p_files - BRNC_FTP_PKG.t_ftp_rec table type. Accepts
* list of files to be transferred (may be any combination of PUT or GET)
* returns the table updated with transfer status, error message,
* bytes_transmitted, transmission start date/time and transmission end
* date/time
* p_username - username for FTP server
* p_password - password for FTP server
* p_hostname - hostname or IP address of server Ex: 'ftp.oracle.com' or '127.0.0.1'
* p_port - port number to connect on. FTP is usually on 21, but this may be overridden
* if the server is configured differently.
FUNCTION FTP_MULTIPLE(p_error_msg OUT VARCHAR2,
 p_files IN OUT t_ftp_rec,
 p_username IN VARCHAR2,
 p_password IN VARCHAR2,
 p_hostname IN VARCHAR2,
 p_port IN PLS_INTEGER DEFAULT 21)
 RETURN BOOLEAN;
* Convenience function for single-file PUT
* Parameters:
* p_localpath - full directory name in which the local file resides or will reside
* Windows: 'd:\oracle\utl_file'
* UNIX: '/home/oracle/utl_file'
* p_filename - filename and extension for the file to be received or sent
* changing the filename for the PUT or GET is currently not allowed
* Examples: 'myfile.dat' 'myfile20021119.xml'
* p_remotepath - full directory name in which the local file will be sent or the
* remote file exists. Should be in UNIX format regardless of FTP server - '/one/two/three'
* p_username - username for FTP server
* p_password - password for FTP server
* p_hostname - FTP server IP address or host name Ex: 'ftp.oracle.com' or '127.0.0.1'
* v_status - status of the transfer. 'ERROR' or 'SUCCESS'
* v_error_message - meaningful (hopefully) error message explaining the reason for failure
* n_bytes_transmitted - how many bytes were sent/received
* d_trans_start - date/time the transmission started
* d_trans_end - date/time the transmission ended
* p_port - port number to connect to, default is 21
* p_filetype - always set to 'ASCII', reserved for future use, ignored in code
FUNCTION PUT(p_localpath IN VARCHAR2,
 p_filename IN VARCHAR2,
 p_remotepath IN VARCHAR2,
 p_username IN VARCHAR2,
 p_password IN VARCHAR2,
 p_hostname IN VARCHAR2,
 v_status OUT VARCHAR2,
 v_error_message OUT VARCHAR2,
 n_bytes_transmitted OUT NUMBER,
 d_trans_start OUT DATE,
d_trans_end OUT DATE,
 p_port IN PLS_INTEGER DEFAULT 21,
 p_filetype IN VARCHAR2 := 'ASCII')
 RETURN BOOLEAN;
* Convenience function for single-file GET
* Parameters:
* p_localpath - full directory name in which the local file resides or will reside
* Windows: 'd:\oracle\utl_file'
* UNIX: '/home/oracle/utl_file'
* p_filename - filename and extension for the file to be received or sent
* changing the filename for the PUT or GET is currently not allowed
* Examples: 'myfile.dat' 'myfile20021119.xml'
* p_remotepath - full directory name in which the local file will be sent or the
* remote file exists. Should be in UNIX format regardless of FTP server - '/one/two/three'
* p_username - username for FTP server
* p_password - password for FTP server
* p_hostname - FTP server IP address or host name Ex: 'ftp.oracle.com' or '127.0.0.1'
* v_status - status of the transfer. 'ERROR' or 'SUCCESS'
* v_error_message - meaningful (hopefully) error message explaining the reason for failure
* n_bytes_transmitted - how many bytes were sent/received
* d_trans_start - date/time the transmission started
* d_trans_end - date/time the transmission ended
* p_port - port number to connect to, default is 21
* p_filetype - always set to 'ASCII', reserved for future use, ignored in code
FUNCTION GET(p_localpath IN VARCHAR2,
 p_filename IN VARCHAR2,
 p_remotepath IN VARCHAR2,
 p_username IN VARCHAR2,
 p_password IN VARCHAR2,
 p_hostname IN VARCHAR2,
 v_status OUT VARCHAR2,
 v_error_message OUT VARCHAR2,
 n_bytes_transmitted OUT NUMBER,
 d_trans_start OUT DATE,
d_trans_end OUT DATE,
 p_port IN PLS_INTEGER DEFAULT 21,
 p_filetype IN VARCHAR2 := 'ASCII')
 RETURN BOOLEAN;
END BRNC_FTP_PKG;
CREATE OR REPLACE PACKAGE BODY BRNC_FTP_PKG
AS
** Create the passive host IP and port number to connect to
PROCEDURE CREATE_PASV(p_pasv_cmd IN VARCHAR2,
 p_pasv_host OUT VARCHAR2,
 p_pasv_port OUT NUMBER)
IS
 v_pasv_cmd VARCHAR2(30) := p_pasv_cmd; --Host and port to connect to for data transfer
n_port_dec NUMBER;
 n_port_add NUMBER;
BEGIN
 p_pasv_host := REPLACE(SUBSTR(v_pasv_cmd,1,INSTR(v_pasv_cmd,',',1,4)-1),',','.');
 n_port_dec := TO_NUMBER(SUBSTR(v_pasv_cmd,INSTR(v_pasv_cmd,',',1,4)+1,(INSTR(v_pasv_cmd,',',1,5)-(INSTR(v_pasv_cmd,',',1,4)+1))));
 n_port_add := TO_NUMBER(SUBSTR(v_pasv_cmd,INSTR(v_pasv_cmd,',',1,5)+1,LENGTH(v_pasv_cmd)-INSTR(v_pasv_cmd,',',1,5)));
 p_pasv_port := (n_port_dec*256) + n_port_add;
EXCEPTION
WHEN OTHERS
THEN
 --DBMS_OUTPUT.PUT_LINE(SQLERRM);
 RAISE;
END CREATE_PASV;
** Read a single or multi-line reply from the FTP server and validate
** it against the code passed in p_code.
** Return TRUE if reply code matches p_code, FALSE if it doesn't or error
** occurs
** Send full server response back to calling procedure
FUNCTION VALIDATE_REPLY(p_ctrl_con IN OUT UTL_TCP.CONNECTION,
 p_code IN PLS_INTEGER,
 p_reply OUT VARCHAR2)
RETURN BOOLEAN
IS
 n_code VARCHAR2(3) := p_code;
 n_byte_count PLS_INTEGER;
 v_msg VARCHAR2(255);
 n_line_count PLS_INTEGER := 0;
BEGIN
 LOOP
 v_msg := UTL_TCP.GET_LINE(p_ctrl_con);
 n_line_count := n_line_count + 1;
 IF n_line_count = 1
 THEN
 p_reply := v_msg;
 ELSE
 p_reply := p_reply || SUBSTR(v_msg,4);
 END IF;
 EXIT WHEN INSTR(v_msg,'-',1,1) <> 4;
 END LOOP;
IF to_number(SUBSTR(p_reply,1,3)) = n_code
 THEN
 RETURN TRUE;
 ELSE
 RETURN FALSE;
 END IF;
EXCEPTION
WHEN OTHERS
THEN
p_reply := SQLERRM;
RETURN FALSE;
END VALIDATE_REPLY;
** Reads a single or multi-line reply from the FTP server
** Return TRUE if reply code matches p_code1 or p_code2,
** FALSE if it doesn't or error occurs
** Send full server response back to calling procedure
FUNCTION VALIDATE_REPLY(p_ctrl_con IN OUT UTL_TCP.CONNECTION,
 p_code1 IN PLS_INTEGER,
 p_code2 IN PLS_INTEGER,
 p_reply OUT VARCHAR2)
RETURN BOOLEAN
IS
 v_code1 VARCHAR2(3) := to_char(p_code1);
 v_code2 VARCHAR2(3) := to_char(p_code2);
 v_msg VARCHAR2(255);
 n_line_count PLS_INTEGER := 0;
BEGIN
 LOOP
 v_msg := UTL_TCP.GET_LINE(p_ctrl_con);
 n_line_count := n_line_count + 1;
 IF n_line_count = 1
 THEN
 p_reply := v_msg;
 ELSE
 p_reply := p_reply || SUBSTR(v_msg,4);
 END IF;
 EXIT WHEN INSTR(v_msg,'-',1,1) <> 4;
 END LOOP;
IF to_number(SUBSTR(p_reply,1,3)) IN(v_code1,v_code2)
 THEN
 RETURN TRUE;
 ELSE
 RETURN FALSE;
 END IF;
EXCEPTION
WHEN OTHERS
THEN
p_reply := SQLERRM;
RETURN FALSE;
END VALIDATE_REPLY;
** Handles actual data transfer. Responds with status, error message, and
** transfer statistics.
** Potential errors could be with connection or file i/o
PROCEDURE TRANSFER_ASCII(u_ctrl_con IN OUT UTL_TCP.CONNECTION,
 p_localpath IN VARCHAR2,
 p_filename IN VARCHAR2,
 p_pasv_host IN VARCHAR2,
 p_pasv_port IN PLS_INTEGER,
 p_transfer_mode IN VARCHAR2,
 v_status OUT VARCHAR2,
 v_error_message OUT VARCHAR2,
 n_bytes_transmitted OUT NUMBER,
 d_trans_start OUT DATE,
d_trans_end OUT DATE)
IS
 u_data_con UTL_TCP.CONNECTION;
 u_filehandle UTL_FILE.FILE_TYPE;
v_tsfr_mode VARCHAR2(3) := p_transfer_mode;
 v_mode VARCHAR2(1);
v_tsfr_cmd VARCHAR2(10);
 v_buffer VARCHAR2(32767);
 v_localpath VARCHAR2(255) := p_localpath;
 v_filename VARCHAR2(255) := p_filename;
 v_host VARCHAR2(20) := p_pasv_host;
 n_port PLS_INTEGER := p_pasv_port;
 n_bytes NUMBER;
 v_msg VARCHAR2(255);
 v_reply VARCHAR2(1000);
 v_err_status VARCHAR2(20) := 'ERROR';
BEGIN
 /** Initialize some of our OUT variables **/
 v_status := 'SUCCESS';
 v_error_message := ' ';
 n_bytes_transmitted := 0;
 IF UPPER(v_tsfr_mode) = 'PUT'
THEN
 v_mode := 'r';
 v_tsfr_cmd := 'STOR ';
 ELSIF UPPER(v_tsfr_mode) = 'GET'
 THEN
 v_mode := 'w';
 v_tsfr_cmd := 'RETR ';
END IF;
 /** Open data connection on Passive host and port **/
 u_data_con := UTL_TCP.OPEN_CONNECTION(v_host,n_port);
 /** Open the local file to read and transfer data **/
 u_filehandle := UTL_FILE.FOPEN(v_localpath,v_filename,v_mode);
 /** Send the STOR command to tell the server we're going to upload a file **/
 n_bytes := UTL_TCP.WRITE_LINE(u_ctrl_con,v_tsfr_cmd||v_filename);
 IF VALIDATE_REPLY(u_ctrl_con,TSFR_START_CODE1,TSFR_START_CODE2,v_reply) = FALSE
 THEN
 RAISE ctrl_exception;
 END IF;
 d_trans_start := SYSDATE;
 IF UPPER(v_tsfr_mode) = 'PUT'
 THEN
 LOOP
 BEGIN
 UTL_FILE.GET_LINE(u_filehandle,v_buffer);
 EXCEPTION
 WHEN NO_DATA_FOUND
 THEN
 EXIT;
 END;
 n_bytes := UTL_TCP.WRITE_LINE(u_data_con,v_buffer);
 n_bytes_transmitted := n_bytes_transmitted + n_bytes;
 END LOOP;
 ELSIF UPPER(v_tsfr_mode) = 'GET'
 THEN
 LOOP
 BEGIN
 v_buffer := UTL_TCP.GET_LINE(u_data_con,TRUE);
 /** Sometimes the TCP/IP buffer sends null data **/
/** we only want to receive the actual data **/
 IF v_buffer IS NOT NULL
 THEN
 UTL_FILE.PUT_LINE(u_filehandle,v_buffer);
 n_bytes := LENGTH(v_buffer);
 n_bytes_transmitted := n_bytes_transmitted + n_bytes;
 END IF;
 EXCEPTION
 WHEN UTL_TCP.END_OF_INPUT
 THEN
 EXIT;
 END;
 END LOOP;
 END IF;
 /** Flush the buffer on the data connection **/
 --UTL_TCP.FLUSH(u_data_con);
 d_trans_end := SYSDATE;
 /** Close the file **/
 UTL_FILE.FCLOSE(u_filehandle);
 /** Close the Data Connection **/
 UTL_TCP.CLOSE_CONNECTION(u_data_con);
 /** Verify the transfer succeeded **/
 IF VALIDATE_REPLY(u_ctrl_con,TSFR_END_CODE,v_reply) = FALSE
 THEN
 RAISE ctrl_exception;
 END IF;
EXCEPTION
WHEN ctrl_exception
THEN
 v_status := v_err_status;
 v_error_message := v_reply;
 IF UTL_FILE.IS_OPEN(u_filehandle)
 THEN
 UTL_FILE.FCLOSE(u_filehandle);
 END IF;
 UTL_TCP.CLOSE_CONNECTION(u_data_con);
WHEN UTL_FILE.invalid_path
THEN
 v_status := v_err_status;
 v_error_message := 'Directory '||v_localpath||' is not available to UTL_FILE. Check the init.ora file for valid UTL_FILE directories.';
 UTL_TCP.CLOSE_CONNECTION(u_data_con);
WHEN UTL_FILE.invalid_operation
THEN
 v_status := v_err_status;
 IF UPPER(v_tsfr_mode) = 'PUT'
 THEN
 v_error_message := 'The file '||V_filename||' in the directory '||v_localpath||' could not be opened for reading.';
 ELSIF UPPER(v_tsfr_mode) = 'GET'
 THEN
 v_error_message := 'The file '||V_filename||' in the directory '||v_localpath||' could not be opened for writing.';
 END IF;
 IF UTL_FILE.IS_OPEN(u_filehandle)
 THEN
 UTL_FILE.FCLOSE(u_filehandle);
 END IF;
 UTL_TCP.CLOSE_CONNECTION(u_data_con);
WHEN UTL_FILE.read_error
THEN
 v_status := v_err_status;
 v_error_message := 'The system encountered an error while trying to read '||v_filename||' in the directory '||v_localpath;
 IF UTL_FILE.IS_OPEN(u_filehandle)
 THEN
 UTL_FILE.FCLOSE(u_filehandle);
 END IF;
 UTL_TCP.CLOSE_CONNECTION(u_data_con);
WHEN UTL_FILE.write_error
THEN
 v_status := v_err_status;
 v_error_message := 'The system encountered an error while trying to write to '||v_filename||' in the directory '||v_localpath;
 IF UTL_FILE.IS_OPEN(u_filehandle)
 THEN
 UTL_FILE.FCLOSE(u_filehandle);
 END IF;
 UTL_TCP.CLOSE_CONNECTION(u_data_con);
WHEN UTL_FILE.internal_error
THEN
 v_status := v_err_status;
 v_error_message := 'The UTL_FILE package encountered an unexpected internal system error.';
 IF UTL_FILE.IS_OPEN(u_filehandle)
 THEN
 UTL_FILE.FCLOSE(u_filehandle);
 END IF;
 UTL_TCP.CLOSE_CONNECTION(u_data_con);
WHEN OTHERS
THEN
 v_status := v_err_status;
 v_error_message := SQLERRM;
 IF UTL_FILE.IS_OPEN(u_filehandle)
 THEN
 UTL_FILE.FCLOSE(u_filehandle);
 END IF;
 UTL_TCP.CLOSE_CONNECTION(u_data_con);
END TRANSFER_ASCII;
** Handles connection to host and FTP of multiple files
** Files can be any combination of PUT and GET
FUNCTION FTP_MULTIPLE(p_error_msg OUT VARCHAR2,
 p_files IN OUT t_ftp_rec,
 p_username IN VARCHAR2,
 p_password IN VARCHAR2,
 p_hostname IN VARCHAR2,
 p_port IN PLS_INTEGER DEFAULT 21)
RETURN BOOLEAN
IS
 v_username VARCHAR2(30) := p_username;
 v_password VARCHAR2(30) := p_password;
 v_hostname VARCHAR2(30) := p_hostname;
 n_port PLS_INTEGER := p_port;
 u_ctrl_con UTL_TCP.CONNECTION;
 n_byte_count PLS_INTEGER;
 n_first_index NUMBER;
 v_msg VARCHAR2(250);
 v_reply VARCHAR2(1000);
v_pasv_host VARCHAR2(20);
n_pasv_port NUMBER;
 invalid_transfer EXCEPTION;
BEGIN
 p_error_msg := 'FTP Successful'; --Assume the overall transfer will succeed
 /** Attempt to connect to the host machine **/
 u_ctrl_con := UTL_TCP.OPEN_CONNECTION(v_hostname,n_port);
 IF VALIDATE_REPLY(u_ctrl_con,CONNECT_CODE,v_reply) = FALSE
 THEN
 RAISE ctrl_exception;
 END IF;
 /** Send username **/
 n_byte_count := UTL_TCP.WRITE_LINE(u_ctrl_con,'USER '||v_username);
 IF VALIDATE_REPLY(u_ctrl_con,USER_CODE,v_reply) = FALSE
 THEN
 RAISE ctrl_exception;
 END IF;
 /** Send password **/
 n_byte_count := UTL_TCP.WRITE_LINE(u_ctrl_con,'PASS '||v_password);
 IF VALIDATE_REPLY(u_ctrl_con,LOGIN_CODE,v_reply) = FALSE
 THEN
 RAISE ctrl_exception;
 END IF;
 /** We should be logged in, time to transfer all files **/
 FOR i IN p_files.FIRST..p_files.LAST
LOOP
 IF p_files.EXISTS(i)
 THEN
 BEGIN
 /** Change to the remotepath directory **/
 n_byte_count := UTL_TCP.WRITE_LINE(u_ctrl_con,'CWD '||p_files(i).remotepath);
 IF VALIDATE_REPLY(u_ctrl_con,CWD_CODE,v_reply) = FALSE
 THEN
 RAISE ctrl_exception;
 END IF;
 /** Switch to IMAGE mode **/
 n_byte_count := UTL_TCP.WRITE_LINE(u_ctrl_con,'TYPE I');
 IF VALIDATE_REPLY(u_ctrl_con,TYPE_CODE,v_reply) = FALSE
 THEN
 RAISE ctrl_exception;
 END IF;
 /** Get a Passive connection to use for data transfer **/
 n_byte_count := UTL_TCP.WRITE_LINE(u_ctrl_con,'PASV');
 IF VALIDATE_REPLY(u_ctrl_con,PASV_CODE,v_reply) = FALSE
 THEN
 RAISE ctrl_exception;
 END IF;
 CREATE_PASV(SUBSTR(v_reply,INSTR(v_reply,'(',1,1)+1,INSTR(v_reply,')',1,1)-INSTR(v_reply,'(',1,1)-1),v_pasv_host,n_pasv_port);
 /** Transfer Data **/
 IF UPPER(p_files(i).transfer_mode) = 'PUT'
 THEN
 TRANSFER_ASCII(u_ctrl_con,
 p_files(i).localpath,
 p_files(i).filename,
 v_pasv_host,
 n_pasv_port,
 p_files(i).transfer_mode,
 p_files(i).status,
 p_files(i).error_message,
 p_files(i).bytes_transmitted,
 p_files(i).trans_start,
 p_files(i).trans_end);
 ELSIF UPPER(p_files(i).transfer_mode) = 'GET'
 THEN
 TRANSFER_ASCII(u_ctrl_con,
 p_files(i).localpath,
 p_files(i).filename,
 v_pasv_host,
 n_pasv_port,
 p_files(i).transfer_mode,
 p_files(i).status,
 p_files(i).error_message,
 p_files(i).bytes_transmitted,
 p_files(i).trans_start,
 p_files(i).trans_end);
 ELSE
 RAISE invalid_transfer; -- Raise an exception here
 END IF;
 EXCEPTION
 WHEN ctrl_exception
 THEN
 p_files(i).status := 'ERROR';
 p_files(i).error_message := v_reply;
 WHEN invalid_transfer
 THEN
 p_files(i).status := 'ERROR';
 p_files(i).error_message := 'Invalid transfer method. Use PUT or GET.';
 END;
 END IF;
 END LOOP;
 /** Send QUIT command **/
 n_byte_count := UTL_TCP.WRITE_LINE(u_ctrl_con,'QUIT');
 /** Don't need to validate QUIT, just close the connection **/
 UTL_TCP.CLOSE_CONNECTION(u_ctrl_con);
 RETURN TRUE;
EXCEPTION
WHEN ctrl_exception
THEN
 p_error_msg := v_reply;
 UTL_TCP.CLOSE_ALL_CONNECTIONS;
 RETURN FALSE;
WHEN OTHERS
THEN
 p_error_msg := SQLERRM;
 UTL_TCP.CLOSE_ALL_CONNECTIONS;
 RETURN FALSE;
END FTP_MULTIPLE;
** Convenience function for single-file PUT
** Formats file information for FTP_MULTIPLE function and calls it.
FUNCTION PUT(p_localpath IN VARCHAR2,
 p_filename IN VARCHAR2,
 p_remotepath IN VARCHAR2,
 p_username IN VARCHAR2,
 p_password IN VARCHAR2,
 p_hostname IN VARCHAR2,
 v_status OUT VARCHAR2,
 v_error_message OUT VARCHAR2,
 n_bytes_transmitted OUT NUMBER,
 d_trans_start OUT DATE,
d_trans_end OUT DATE,
 p_port IN PLS_INTEGER DEFAULT 21,
 p_filetype IN VARCHAR2 := 'ASCII')
RETURN BOOLEAN
IS
 t_files t_ftp_rec;
 v_username VARCHAR2(30) := p_username;
 v_password VARCHAR2(50) := p_password;
 v_hostname VARCHAR2(100) := p_hostname;
 n_port PLS_INTEGER := p_port;
v_err_msg VARCHAR2(255);
 b_ftp BOOLEAN;
BEGIN
 t_files(1).localpath := p_localpath;
 t_files(1).filename := p_filename;
 t_files(1).remotepath := p_remotepath;
 t_files(1).filetype := p_filetype;
 t_files(1).transfer_mode := 'PUT';
 b_ftp := FTP_MULTIPLE(v_err_msg,
 t_files,
 v_username,
 v_password,
 v_hostname,
 n_port);
 IF b_ftp = FALSE
 THEN
 v_status := 'ERROR';
 v_error_message := v_err_msg;
 RETURN FALSE;
 ELSIF b_ftp = TRUE
 THEN
 v_status := t_files(1).status;
 v_error_message := t_files(1).error_message;
 n_bytes_transmitted := t_files(1).bytes_transmitted;
 d_trans_start := t_files(1).trans_start;
 d_trans_end := t_files(1).trans_end;
 RETURN TRUE;
 END IF;
EXCEPTION
WHEN OTHERS
THEN
 v_status := 'ERROR';
 v_error_message := SQLERRM;
 RETURN FALSE;
 --DBMS_OUTPUT.PUT_LINE(SQLERRM);
END PUT;
** Convenience function for single-file GET
** Formats file information for FTP_MULTIPLE function and calls it.
FUNCTION GET(p_localpath IN VARCHAR2,
 p_filename IN VARCHAR2,
 p_remotepath IN VARCHAR2,
 p_username IN VARCHAR2,
 p_password IN VARCHAR2,
 p_hostname IN VARCHAR2,
 v_status OUT VARCHAR2,
 v_error_message OUT VARCHAR2,
 n_bytes_transmitted OUT NUMBER,
 d_trans_start OUT DATE,
d_trans_end OUT DATE,
 p_port IN PLS_INTEGER DEFAULT 21,
 p_filetype IN VARCHAR2 := 'ASCII')
RETURN BOOLEAN
IS
 t_files t_ftp_rec;
 v_username VARCHAR2(30) := p_username;
 v_password VARCHAR2(50) := p_password;
 v_hostname VARCHAR2(100) := p_hostname;
 n_port PLS_INTEGER := p_port;
v_err_msg VARCHAR2(255);
 b_ftp BOOLEAN;
BEGIN
 t_files(1).localpath := p_localpath;
 t_files(1).filename := p_filename;
 t_files(1).remotepath := p_remotepath;
 t_files(1).filetype := p_filetype;
 t_files(1).transfer_mode := 'GET';
 b_ftp := FTP_MULTIPLE(v_err_msg,
 t_files,
 v_username,
 v_password,
 v_hostname,
 n_port);
 IF b_ftp = FALSE
 THEN
 v_status := 'ERROR';
 v_error_message := v_err_msg;
 RETURN FALSE;
 ELSIF b_ftp = TRUE
 THEN
 v_status := t_files(1).status;
 v_error_message := t_files(1).error_message;
 n_bytes_transmitted := t_files(1).bytes_transmitted;
 d_trans_start := t_files(1).trans_start;
 d_trans_end := t_files(1).trans_end;
 RETURN TRUE;
 END IF;
EXCEPTION
WHEN OTHERS
THEN
 v_status := 'ERROR';
 v_error_message := SQLERRM;
 RETURN FALSE;
 --DBMS_OUTPUT.PUT_LINE(SQLERRM);
END GET;
END BRNC_FTP_PKG;
/

Business Objects Enterprise 11.5 FTP Transfer Problem

Hello,
Hopefully someone out there will be familiar with the issue I'm having and be able to provide a solution.
We are running Business Objects Enterprise 11.5 on our Windows 2003 server. I've created and scheduled a job on the server that creates an XLS file containing loan portfolio data that is to be transmitted to a third party client on a monthly basis.
The problem centers around the method of transfer, which is via FTP to a secure site hosted by the client. When executed through Crystal, the FTP actually does achieve a successful login using the credentials the client provided (we have verified this repeatedly by looking at the logs), but the client's server "kicks out" when we attempt any operation on it.
A similar result was produced when we attempted to FTP to the site via the Windows command line. The login was successful, but even a simple command to view the directory "dir" resulted in the connection being rejected. To make a long story short, after reviewing the issue extensively with the client's technical department, our conclusion was that the problem was the result of the FTP sending in "active" mode instead of "passive". We confirmed this by installing a freeware FileZilla on the same server, and switching between active and passive modes (active failed, passive did not).
Their tech people recommended that we contact SAP to get answers to two questions, which I'm hoping someone out there may know:
1) How does Business Objects Enterprise 11.5 execute the FTP process? Is it using its own native logic or simply invoking the command line?
2) Is there any setting with the console that would enable us to modify the FTP settings to send force it to send in passive mode?
Thanks.

Hi,
This is a known limitation. BO only supports active mode for FTP. Refer 1782115 - Which FTP mode is supported as a schedule or publication destination for reference.
If you are able to write a batch file or a program object to transfer a file from a file location to Client FTP, you can try the below workaround.
1. Add the script\batch file as a program object in BO. In the script make sure you include the code to delete the instance after it is successfully transmitted through FTP.
2. Create a File event pointing to the location along with the name of the instance.
3. Schedule the report to the file location with the specific instance name.
4. Schedule the program object based on the file event you created in step 2.
Hope this helps.
Regards
Chinmaya

FTP process

Similar Messages

Maybe you are looking for