/* * scp - SSH scp wrapper functions * * This file is part of the SSH Library * * Copyright (c) 2009 by Aris Adamantiadis * * The SSH Library is free software; you can redistribute it and/or modify * it under the terms of the GNU Lesser General Public License as published by * the Free Software Foundation; either version 2.1 of the License, or (at your * option) any later version. * * The SSH Library is distributed in the hope that it will be useful, but * WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY * or FITNESS FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public * License for more details. * * You should have received a copy of the GNU Lesser General Public License * along with the SSH Library; see the file COPYING. If not, write to * the Free Software Foundation, Inc., 59 Temple Place - Suite 330, Boston, * MA 02111-1307, USA. */ #include "config.h" #include #include #include #include "libssh/priv.h" #include "libssh/scp.h" /** * @defgroup libssh_scp The SSH scp functions * @ingroup libssh * * SCP protocol over SSH functions * * @{ */ /** * @brief Create a new scp session. * * @param[in] session The SSH session to use. * * @param[in] mode One of SSH_SCP_WRITE or SSH_SCP_READ, depending if you * need to drop files remotely or read them. * It is not possible to combine read and write. * SSH_SCP_RECURSIVE Flag can be or'ed to this to indicate * that you're going to use recursion. Browsing through * directories is not possible without this. * * @param[in] location The directory in which write or read will be done. Any * push or pull will be relative to this place. * This can also be a pattern of files to download (read). * * @returns A ssh_scp handle, NULL if the creation was impossible. */ ssh_scp ssh_scp_new(ssh_session session, int mode, const char *location){ ssh_scp scp=malloc(sizeof(struct ssh_scp_struct)); if(scp == NULL){ ssh_set_error(session,SSH_FATAL,"Error allocating memory for ssh_scp"); return NULL; } ZERO_STRUCTP(scp); if((mode&~SSH_SCP_RECURSIVE) != SSH_SCP_WRITE && (mode &~SSH_SCP_RECURSIVE) != SSH_SCP_READ){ ssh_set_error(session,SSH_FATAL,"Invalid mode %d for ssh_scp_new()",mode); ssh_scp_free(scp); return NULL; } scp->location=strdup(location); if (scp->location == NULL) { ssh_set_error(session,SSH_FATAL,"Error allocating memory for ssh_scp"); ssh_scp_free(scp); return NULL; } scp->session=session; scp->mode=mode & ~SSH_SCP_RECURSIVE; scp->recursive = (mode & SSH_SCP_RECURSIVE) != 0; scp->channel=NULL; scp->state=SSH_SCP_NEW; return scp; } /** * @brief Initialize the scp channel. * * @param[in] scp The scp context to initialize. * * @return SSH_OK on success or an SSH error code. * * @see ssh_scp_new() */ int ssh_scp_init(ssh_scp scp) { int r; char execbuffer[1024]; uint8_t code; if(scp==NULL) return SSH_ERROR; if(scp->state != SSH_SCP_NEW){ ssh_set_error(scp->session,SSH_FATAL,"ssh_scp_init called under invalid state"); return SSH_ERROR; } SSH_LOG(SSH_LOG_PROTOCOL,"Initializing scp session %s %son location '%s'", scp->mode==SSH_SCP_WRITE?"write":"read", scp->recursive?"recursive ":"", scp->location); scp->channel=ssh_channel_new(scp->session); if(scp->channel == NULL){ scp->state=SSH_SCP_ERROR; return SSH_ERROR; } r= ssh_channel_open_session(scp->channel); if(r==SSH_ERROR){ scp->state=SSH_SCP_ERROR; return SSH_ERROR; } if(scp->mode == SSH_SCP_WRITE) snprintf(execbuffer,sizeof(execbuffer),"scp -t %s %s", scp->recursive ? "-r":"", scp->location); else snprintf(execbuffer,sizeof(execbuffer),"scp -f %s %s", scp->recursive ? "-r":"", scp->location); if(ssh_channel_request_exec(scp->channel,execbuffer) == SSH_ERROR){ scp->state=SSH_SCP_ERROR; return SSH_ERROR; } if(scp->mode == SSH_SCP_WRITE){ r=ssh_channel_read(scp->channel,&code,1,0); if(r<=0){ ssh_set_error(scp->session,SSH_FATAL, "Error reading status code: %s",ssh_get_error(scp->session)); scp->state=SSH_SCP_ERROR; return SSH_ERROR; } if(code != 0){ ssh_set_error(scp->session,SSH_FATAL, "scp status code %ud not valid", code); scp->state=SSH_SCP_ERROR; return SSH_ERROR; } } else { ssh_channel_write(scp->channel,"",1); } if(scp->mode == SSH_SCP_WRITE) scp->state=SSH_SCP_WRITE_INITED; else scp->state=SSH_SCP_READ_INITED; return SSH_OK; } /** * @brief Close the scp channel. * * @param[in] scp The scp context to close. * * @return SSH_OK on success or an SSH error code. * * @see ssh_scp_init() */ int ssh_scp_close(ssh_scp scp) { char buffer[128]; int err; if(scp==NULL) return SSH_ERROR; if(scp->channel != NULL){ if(ssh_channel_send_eof(scp->channel) == SSH_ERROR){ scp->state=SSH_SCP_ERROR; return SSH_ERROR; } /* avoid situations where data are buffered and * not yet stored on disk. This can happen if the close is sent * before we got the EOF back */ while(!ssh_channel_is_eof(scp->channel)){ err=ssh_channel_read(scp->channel,buffer,sizeof(buffer),0); if(err==SSH_ERROR || err==0) break; } if(ssh_channel_close(scp->channel) == SSH_ERROR){ scp->state=SSH_SCP_ERROR; return SSH_ERROR; } ssh_channel_free(scp->channel); scp->channel=NULL; } scp->state=SSH_SCP_NEW; return SSH_OK; } /** * @brief Free a scp context. * * @param[in] scp The context to free. * * @see ssh_scp_new() */ void ssh_scp_free(ssh_scp scp) { if(scp==NULL) return; if(scp->state != SSH_SCP_NEW) ssh_scp_close(scp); if(scp->channel) ssh_channel_free(scp->channel); SAFE_FREE(scp->location); SAFE_FREE(scp->request_name); SAFE_FREE(scp->warning); SAFE_FREE(scp); } /** * @brief Create a directory in a scp in sink mode. * * @param[in] scp The scp handle. * * @param[in] dirname The name of the directory being created. * * @param[in] mode The UNIX permissions for the new directory, e.g. 0755. * * @returns SSH_OK if the directory has been created, SSH_ERROR if * an error occured. * * @see ssh_scp_leave_directory() */ int ssh_scp_push_directory(ssh_scp scp, const char *dirname, int mode){ char buffer[1024]; int r; uint8_t code; char *dir; char *perms; if(scp==NULL) return SSH_ERROR; if(scp->state != SSH_SCP_WRITE_INITED){ ssh_set_error(scp->session,SSH_FATAL,"ssh_scp_push_directory called under invalid state"); return SSH_ERROR; } dir=ssh_basename(dirname); perms=ssh_scp_string_mode(mode); snprintf(buffer, sizeof(buffer), "D%s 0 %s\n", perms, dir); SAFE_FREE(dir); SAFE_FREE(perms); r=ssh_channel_write(scp->channel,buffer,strlen(buffer)); if(r==SSH_ERROR){ scp->state=SSH_SCP_ERROR; return SSH_ERROR; } r=ssh_channel_read(scp->channel,&code,1,0); if(r<=0){ ssh_set_error(scp->session,SSH_FATAL, "Error reading status code: %s",ssh_get_error(scp->session)); scp->state=SSH_SCP_ERROR; return SSH_ERROR; } if(code != 0){ ssh_set_error(scp->session,SSH_FATAL, "scp status code %ud not valid", code); scp->state=SSH_SCP_ERROR; return SSH_ERROR; } return SSH_OK; } /** * @brief Leave a directory. * * @returns SSH_OK if the directory has been left,SSH_ERROR if an * error occured. * * @see ssh_scp_push_directory() */ int ssh_scp_leave_directory(ssh_scp scp){ char buffer[]="E\n"; int r; uint8_t code; if(scp==NULL) return SSH_ERROR; if(scp->state != SSH_SCP_WRITE_INITED){ ssh_set_error(scp->session,SSH_FATAL,"ssh_scp_leave_directory called under invalid state"); return SSH_ERROR; } r=ssh_channel_write(scp->channel,buffer,strlen(buffer)); if(r==SSH_ERROR){ scp->state=SSH_SCP_ERROR; return SSH_ERROR; } r=ssh_channel_read(scp->channel,&code,1,0); if(r<=0){ ssh_set_error(scp->session,SSH_FATAL, "Error reading status code: %s",ssh_get_error(scp->session)); scp->state=SSH_SCP_ERROR; return SSH_ERROR; } if(code != 0){ ssh_set_error(scp->session,SSH_FATAL, "scp status code %ud not valid", code); scp->state=SSH_SCP_ERROR; return SSH_ERROR; } return SSH_OK; } /** * @brief Initialize the sending of a file to a scp in sink mode, using a 64-bit size. * * @param[in] scp The scp handle. * * @param[in] filename The name of the file being sent. It should not contain * any path indicator * * @param[in] size Exact size in bytes of the file being sent. * * @param[in] mode The UNIX permissions for the new file, e.g. 0644. * * @returns SSH_OK if the file is ready to be sent, SSH_ERROR if an * error occured. * * @see ssh_scp_push_file() */ int ssh_scp_push_file64(ssh_scp scp, const char *filename, uint64_t size, int mode){ char buffer[1024]; int r; uint8_t code; char *file; char *perms; if(scp==NULL) return SSH_ERROR; if(scp->state != SSH_SCP_WRITE_INITED){ ssh_set_error(scp->session,SSH_FATAL,"ssh_scp_push_file called under invalid state"); return SSH_ERROR; } file=ssh_basename(filename); perms=ssh_scp_string_mode(mode); SSH_LOG(SSH_LOG_PROTOCOL,"SCP pushing file %s, size %" PRIu64 " with permissions '%s'",file,size,perms); snprintf(buffer, sizeof(buffer), "C%s %" PRIu64 " %s\n", perms, size, file); SAFE_FREE(file); SAFE_FREE(perms); r=ssh_channel_write(scp->channel,buffer,strlen(buffer)); if(r==SSH_ERROR){ scp->state=SSH_SCP_ERROR; return SSH_ERROR; } r=ssh_channel_read(scp->channel,&code,1,0); if(r<=0){ ssh_set_error(scp->session,SSH_FATAL, "Error reading status code: %s",ssh_get_error(scp->session)); scp->state=SSH_SCP_ERROR; return SSH_ERROR; } if(code != 0){ ssh_set_error(scp->session,SSH_FATAL, "scp status code %ud not valid", code); scp->state=SSH_SCP_ERROR; return SSH_ERROR; } scp->filelen = size; scp->processed = 0; scp->state=SSH_SCP_WRITE_WRITING; return SSH_OK; } /** * @brief Initialize the sending of a file to a scp in sink mode. * * @param[in] scp The scp handle. * * @param[in] filename The name of the file being sent. It should not contain * any path indicator * * @param[in] size Exact size in bytes of the file being sent. * * @param[in] mode The UNIX permissions for the new file, e.g. 0644. * * @returns SSH_OK if the file is ready to be sent, SSH_ERROR if an * error occured. */ int ssh_scp_push_file(ssh_scp scp, const char *filename, size_t size, int mode){ return ssh_scp_push_file64(scp, filename, (uint64_t) size, mode); } /** * @internal * * @brief Wait for a response of the scp server. * * @param[in] scp The scp handle. * * @param[out] response A pointer where the response message must be copied if * any. This pointer must then be free'd. * * @returns The return code, SSH_ERROR a error occured. */ int ssh_scp_response(ssh_scp scp, char **response){ unsigned char code; int r; char msg[128]; if(scp==NULL) return SSH_ERROR; r=ssh_channel_read(scp->channel,&code,1,0); if(r == SSH_ERROR) return SSH_ERROR; if(code == 0) return 0; if(code > 2){ ssh_set_error(scp->session,SSH_FATAL, "SCP: invalid status code %ud received", code); scp->state=SSH_SCP_ERROR; return SSH_ERROR; } r=ssh_scp_read_string(scp,msg,sizeof(msg)); if(r==SSH_ERROR) return r; /* Warning */ if(code == 1){ ssh_set_error(scp->session,SSH_REQUEST_DENIED, "SCP: Warning: status code 1 received: %s", msg); SSH_LOG(SSH_LOG_RARE,"SCP: Warning: status code 1 received: %s", msg); if(response) *response=strdup(msg); return 1; } if(code == 2){ ssh_set_error(scp->session,SSH_FATAL, "SCP: Error: status code 2 received: %s", msg); if(response) *response=strdup(msg); return 2; } /* Not reached */ return SSH_ERROR; } /** * @brief Write into a remote scp file. * * @param[in] scp The scp handle. * * @param[in] buffer The buffer to write. * * @param[in] len The number of bytes to write. * * @returns SSH_OK if the write was successful, SSH_ERROR an error * occured while writing. */ int ssh_scp_write(ssh_scp scp, const void *buffer, size_t len){ int w; int r; uint8_t code; if(scp==NULL) return SSH_ERROR; if(scp->state != SSH_SCP_WRITE_WRITING){ ssh_set_error(scp->session,SSH_FATAL,"ssh_scp_write called under invalid state"); return SSH_ERROR; } if(scp->processed + len > scp->filelen) len = (size_t) (scp->filelen - scp->processed); /* hack to avoid waiting for window change */ r = ssh_channel_poll(scp->channel, 0); if (r == SSH_ERROR) { scp->state = SSH_SCP_ERROR; return SSH_ERROR; } w=ssh_channel_write(scp->channel,buffer,len); if(w != SSH_ERROR) scp->processed += w; else { scp->state=SSH_SCP_ERROR; //return=channel_get_exit_status(scp->channel); return SSH_ERROR; } /* Far end sometimes send a status message, which we need to read * and handle */ r = ssh_channel_poll(scp->channel,0); if(r > 0){ r = ssh_channel_read(scp->channel, &code, 1, 0); if(r == SSH_ERROR){ return SSH_ERROR; } if(code == 1 || code == 2){ ssh_set_error(scp->session,SSH_REQUEST_DENIED, "SCP: Error: status code %i received", code); return SSH_ERROR; } } /* Check if we arrived at end of file */ if(scp->processed == scp->filelen) { code = 0; w = ssh_channel_write(scp->channel, &code, 1); if(w == SSH_ERROR){ scp->state = SSH_SCP_ERROR; return SSH_ERROR; } scp->processed=scp->filelen=0; scp->state=SSH_SCP_WRITE_INITED; } return SSH_OK; } /** * @brief Read a string on a channel, terminated by '\n' * * @param[in] scp The scp handle. * * @param[out] buffer A pointer to a buffer to place the string. * * @param[in] len The size of the buffer in bytes. If the string is bigger * than len-1, only len-1 bytes are read and the string is * null-terminated. * * @returns SSH_OK if the string was read, SSH_ERROR if an error * occured while reading. */ int ssh_scp_read_string(ssh_scp scp, char *buffer, size_t len){ size_t r=0; int err=SSH_OK; if(scp==NULL) return SSH_ERROR; while(rchannel,&buffer[r],1,0); if(err==SSH_ERROR){ break; } if(err==0){ ssh_set_error(scp->session,SSH_FATAL,"End of file while reading string"); err=SSH_ERROR; break; } r++; if(buffer[r-1] == '\n') break; } buffer[r]=0; return err; } /** * @brief Wait for a scp request (file, directory). * * @returns SSH_SCP_REQUEST_NEWFILE: The other side is sending * a file * SSH_SCP_REQUEST_NEWDIR: The other side is sending * a directory * SSH_SCP_REQUEST_ENDDIR: The other side has * finished with the current * directory * SSH_SCP_REQUEST_WARNING: The other side sent us a warning * SSH_SCP_REQUEST_EOF: The other side finished sending us * files and data. * SSH_ERROR: Some error happened * * @see ssh_scp_read() * @see ssh_scp_deny_request() * @see ssh_scp_accept_request() * @see ssh_scp_request_get_warning() */ int ssh_scp_pull_request(ssh_scp scp){ char buffer[4096] = {0}; char *mode=NULL; char *p,*tmp; uint64_t size; char *name=NULL; int err; if(scp==NULL) return SSH_ERROR; if(scp->state != SSH_SCP_READ_INITED){ ssh_set_error(scp->session,SSH_FATAL,"ssh_scp_pull_request called under invalid state"); return SSH_ERROR; } err=ssh_scp_read_string(scp,buffer,sizeof(buffer)); if(err==SSH_ERROR){ if(ssh_channel_is_eof(scp->channel)){ scp->state=SSH_SCP_TERMINATED; return SSH_SCP_REQUEST_EOF; } return err; } p=strchr(buffer,'\n'); if(p!=NULL) *p='\0'; SSH_LOG(SSH_LOG_PROTOCOL,"Received SCP request: '%s'",buffer); switch(buffer[0]){ case 'C': /* File */ case 'D': /* Directory */ p=strchr(buffer,' '); if(p==NULL) goto error; *p='\0'; p++; //mode=strdup(&buffer[1]); scp->request_mode=ssh_scp_integer_mode(&buffer[1]); tmp=p; p=strchr(p,' '); if(p==NULL) goto error; *p=0; size = strtoull(tmp,NULL,10); p++; name=strdup(p); SAFE_FREE(scp->request_name); scp->request_name=name; if(buffer[0]=='C'){ scp->filelen=size; scp->request_type=SSH_SCP_REQUEST_NEWFILE; } else { scp->filelen='0'; scp->request_type=SSH_SCP_REQUEST_NEWDIR; } scp->state=SSH_SCP_READ_REQUESTED; scp->processed = 0; return scp->request_type; break; case 'E': scp->request_type=SSH_SCP_REQUEST_ENDDIR; ssh_channel_write(scp->channel,"",1); return scp->request_type; case 0x1: ssh_set_error(scp->session,SSH_REQUEST_DENIED,"SCP: Warning: %s",&buffer[1]); scp->request_type=SSH_SCP_REQUEST_WARNING; SAFE_FREE(scp->warning); scp->warning=strdup(&buffer[1]); return scp->request_type; case 0x2: ssh_set_error(scp->session,SSH_FATAL,"SCP: Error: %s",&buffer[1]); return SSH_ERROR; case 'T': /* Timestamp */ default: ssh_set_error(scp->session,SSH_FATAL,"Unhandled message: (%d)%s",buffer[0],buffer); return SSH_ERROR; } /* a parsing error occured */ error: SAFE_FREE(name); SAFE_FREE(mode); ssh_set_error(scp->session,SSH_FATAL,"Parsing error while parsing message: %s",buffer); return SSH_ERROR; } /** * @brief Deny the transfer of a file or creation of a directory coming from the * remote party. * * @param[in] scp The scp handle. * @param[in] reason A nul-terminated string with a human-readable * explanation of the deny. * * @returns SSH_OK if the message was sent, SSH_ERROR if the sending * the message failed, or sending it in a bad state. */ int ssh_scp_deny_request(ssh_scp scp, const char *reason){ char buffer[4096]; int err; if(scp==NULL) return SSH_ERROR; if(scp->state != SSH_SCP_READ_REQUESTED){ ssh_set_error(scp->session,SSH_FATAL,"ssh_scp_deny_request called under invalid state"); return SSH_ERROR; } snprintf(buffer,sizeof(buffer),"%c%s\n",2,reason); err=ssh_channel_write(scp->channel,buffer,strlen(buffer)); if(err==SSH_ERROR) { return SSH_ERROR; } else { scp->state=SSH_SCP_READ_INITED; return SSH_OK; } } /** * @brief Accepts transfer of a file or creation of a directory coming from the * remote party. * * @param[in] scp The scp handle. * * @returns SSH_OK if the message was sent, SSH_ERROR if sending the * message failed, or sending it in a bad state. */ int ssh_scp_accept_request(ssh_scp scp){ char buffer[]={0x00}; int err; if(scp==NULL) return SSH_ERROR; if(scp->state != SSH_SCP_READ_REQUESTED){ ssh_set_error(scp->session,SSH_FATAL,"ssh_scp_deny_request called under invalid state"); return SSH_ERROR; } err=ssh_channel_write(scp->channel,buffer,1); if(err==SSH_ERROR) { return SSH_ERROR; } if(scp->request_type==SSH_SCP_REQUEST_NEWFILE) scp->state=SSH_SCP_READ_READING; else scp->state=SSH_SCP_READ_INITED; return SSH_OK; } /** @brief Read from a remote scp file * @param[in] scp The scp handle. * * @param[in] buffer The destination buffer. * * @param[in] size The size of the buffer. * * @returns The nNumber of bytes read, SSH_ERROR if an error occured * while reading. */ int ssh_scp_read(ssh_scp scp, void *buffer, size_t size){ int r; int code; if(scp==NULL) return SSH_ERROR; if(scp->state == SSH_SCP_READ_REQUESTED && scp->request_type == SSH_SCP_REQUEST_NEWFILE){ r=ssh_scp_accept_request(scp); if(r==SSH_ERROR) return r; } if(scp->state != SSH_SCP_READ_READING){ ssh_set_error(scp->session,SSH_FATAL,"ssh_scp_read called under invalid state"); return SSH_ERROR; } if(scp->processed + size > scp->filelen) size = (size_t) (scp->filelen - scp->processed); if(size > 65536) size=65536; /* avoid too large reads */ r=ssh_channel_read(scp->channel,buffer,size,0); if(r != SSH_ERROR) scp->processed += r; else { scp->state=SSH_SCP_ERROR; return SSH_ERROR; } /* Check if we arrived at end of file */ if(scp->processed == scp->filelen) { scp->processed=scp->filelen=0; ssh_channel_write(scp->channel,"",1); code=ssh_scp_response(scp,NULL); if(code == 0){ scp->state=SSH_SCP_READ_INITED; return r; } if(code==1){ scp->state=SSH_SCP_READ_INITED; return SSH_ERROR; } scp->state=SSH_SCP_ERROR; return SSH_ERROR; } return r; } /** * @brief Get the name of the directory or file being pushed from the other * party. * * @returns The file name, NULL on error. The string should not be * freed. */ const char *ssh_scp_request_get_filename(ssh_scp scp){ if(scp==NULL) return NULL; return scp->request_name; } /** * @brief Get the permissions of the directory or file being pushed from the * other party. * * @returns The UNIX permission, e.g 0644, -1 on error. */ int ssh_scp_request_get_permissions(ssh_scp scp){ if(scp==NULL) return -1; return scp->request_mode; } /** @brief Get the size of the file being pushed from the other party. * * @returns The numeric size of the file being read. * @warning The real size may not fit in a 32 bits field and may * be truncated. * @see ssh_scp_request_get_size64() */ size_t ssh_scp_request_get_size(ssh_scp scp){ if(scp==NULL) return 0; return (size_t)scp->filelen; } /** @brief Get the size of the file being pushed from the other party. * * @returns The numeric size of the file being read. */ uint64_t ssh_scp_request_get_size64(ssh_scp scp){ if(scp==NULL) return 0; return scp->filelen; } /** * @brief Convert a scp text mode to an integer. * * @param[in] mode The mode to convert, e.g. "0644". * * @returns An integer value, e.g. 420 for "0644". */ int ssh_scp_integer_mode(const char *mode){ int value=strtoul(mode,NULL,8) & 0xffff; return value; } /** * @brief Convert a unix mode into a scp string. * * @param[in] mode The mode to convert, e.g. 420 or 0644. * * @returns A pointer to a malloc'ed string containing the scp mode, * e.g. "0644". */ char *ssh_scp_string_mode(int mode){ char buffer[16]; snprintf(buffer,sizeof(buffer),"%.4d",mode); return strdup(buffer); } /** * @brief Get the warning string from a scp handle. * * @param[in] scp The scp handle. * * @returns A warning string, or NULL on error. The string should * not be freed. */ const char *ssh_scp_request_get_warning(ssh_scp scp){ if(scp==NULL) return NULL; return scp->warning; } /** @} */ /* vim: set ts=4 sw=4 et cindent: */