Beispiel #1
0
int scp_test(ssh_session session, ssh_scp scp)
{
    int rc;
    const char *helloworld = "Hello, world!\n";
    int length = strlen(helloworld);
    
    rc = ssh_scp_push_directory(scp, "helloworld", S_IRWXU);
    if(rc != SSH_OK)
    {
        fprintf(stderr, "Can't create remote directory: %s\n", ssh_get_error(session));
        return rc;
    }
    
    rc = ssh_scp_push_file(scp, "helloworld", length, S_IRUSR | S_IWUSR);
    if(rc != SSH_OK)
    {
        fprintf(stderr, "Can't open remote file: %s\n", ssh_get_error(session));
        return rc;
    }
    
    rc = ssh_scp_write(scp, helloworld, length);
    //ssh_option_set(my_ssh_session, SSH_OPTIONS_HOST, "localhost");
    if(rc != SSH_OK)
    {
        fprintf(stderr, "Can't write remote file: %s\n", ssh_get_error(session));
        return rc;
    }

    return SSH_OK;
}
Beispiel #2
0
static int 
lscp_write(lua_State *L) {
	struct scp_ud * scpud = get_scpud(L);
	if(scpud->scp->state==SSH_SCP_WRITE_INITED){
		return 0;
	}
	size_t len=0;
	const char *buffer=luaL_checklstring(L,2,&len);
	int r=ssh_scp_write(scpud->scp,buffer,len);
	if(r==SSH_ERROR){
		scp_error(L,scpud);
	}
	return 0;
}
Beispiel #3
0
    int SSH::scp(const std::string& filePath, const byte* data, size_t size) {
        ssh_scp scp;
        int rc;

        size_t found = filePath.find_last_of("/\\");
        std::string filename = filePath.substr(found+1);
        std::string path = filePath.substr(0, found+1);

        scp = ssh_scp_new(session_, SSH_SCP_WRITE, path.c_str());
        if (scp == NULL) {
            throw Error(1, ssh_get_error(session_));
            rc = SSH_ERROR;
        } else {
            rc = ssh_scp_init(scp);
            if (rc != SSH_OK) {
                throw Error(1, ssh_get_error(session_));
            } else {
#ifdef  _MSC_VER
// S_IRUSR & S_IWUSR not in MSVC (0000400 & 0000200 in /usr/include/sys/stat.h on MacOS-X 10.8) 
#define S_IRUSR S_IREAD
#define S_IWUSR S_IWRITE
#endif
                rc = ssh_scp_push_file (scp, filename.c_str(), size, S_IRUSR |  S_IWUSR);
                if (rc != SSH_OK) {
                    throw Error(1, ssh_get_error(session_));
                } else {
                    rc = ssh_scp_write(scp, data, size);
                    if (rc != SSH_OK) {
                        throw Error(1, ssh_get_error(session_));
                    }
                }
                ssh_scp_close(scp);
            }
            ssh_scp_free(scp);
        }

        return rc;
    }
Beispiel #4
0
/** @brief copies files from source location to destination
 * @param src source location
 * @param dest destination location
 * @param recursive Copy also directories
 */
static int do_copy(struct location *src, struct location *dest, int recursive){
  int size;
  socket_t fd;
  struct stat s;
  int w,r;
  char buffer[16384];
  int total=0;
  int mode;
  char *filename;
  /* recursive mode doesn't work yet */
  (void)recursive;
  /* Get the file name and size*/
  if(!src->is_ssh){
    fd=fileno(src->file);
    fstat(fd,&s);
    size=s.st_size;
    mode = s.st_mode & S_IFMT;
    filename=ssh_basename(src->path);
  } else {
    size=0;
    do {
        r=ssh_scp_pull_request(src->scp);
        if(r==SSH_SCP_REQUEST_NEWDIR){
                ssh_scp_deny_request(src->scp,"Not in recursive mode");
                continue;
        }
        if(r==SSH_SCP_REQUEST_NEWFILE){
                size=ssh_scp_request_get_size(src->scp);
                filename=strdup(ssh_scp_request_get_filename(src->scp));
                mode=ssh_scp_request_get_permissions(src->scp);
                //ssh_scp_accept_request(src->scp);
                break;
        }
        if(r==SSH_ERROR){
                fprintf(stderr,"Error: %s\n",ssh_get_error(src->session));
                return -1;
        }
    } while(r != SSH_SCP_REQUEST_NEWFILE);
  }

  if(dest->is_ssh){
          r=ssh_scp_push_file(dest->scp,src->path, size, mode);
          //  snprintf(buffer,sizeof(buffer),"C0644 %d %s\n",size,src->path);
          if(r==SSH_ERROR){
                  fprintf(stderr,"error: %s\n",ssh_get_error(dest->session));
                  ssh_scp_free(dest->scp);
                  return -1;
          }
  } else {
          if(!dest->file){
                  dest->file=fopen(filename,"w");
                  if(!dest->file){
                          fprintf(stderr,"Cannot open %s for writing: %s\n",filename,strerror(errno));
                          if(src->is_ssh)
                                  ssh_scp_deny_request(src->scp,"Cannot open local file");
                          return -1;
                  }
          }
          if(src->is_ssh){
                  ssh_scp_accept_request(src->scp);
          }
  }
  do {
          if(src->is_ssh){
                  r=ssh_scp_read(src->scp,buffer,sizeof(buffer));
                  if(r==SSH_ERROR){
                          fprintf(stderr,"Error reading scp: %s\n",ssh_get_error(src->session));
                          return -1;
                  }
                  if(r==0)
                          break;
          } else {
                  r=fread(buffer,1,sizeof(buffer),src->file);
                  if(r==0)
                          break;
                  if(r<0){
                          fprintf(stderr,"Error reading file: %s\n",strerror(errno));
                          return -1;
                  }
          }
          if(dest->is_ssh){
                  w=ssh_scp_write(dest->scp,buffer,r);
                  if(w == SSH_ERROR){
                          fprintf(stderr,"Error writing in scp: %s\n",ssh_get_error(dest->session));
                          ssh_scp_free(dest->scp);
                          dest->scp=NULL;
                          return -1;
                  }
          } else {
                  w=fwrite(buffer,r,1,dest->file);
                  if(w<=0){
                          fprintf(stderr,"Error writing in local file: %s\n",strerror(errno));
                          return -1;
                  }
          }
          total+=r;

  } while(total < size);
 printf("wrote %d bytes\n",total);
 return 0;
}
Beispiel #5
0
static int do_scp_write(ssh_scp scp, const char* path, FILE* fp,
                        ftp_transfer_func hookf)
{
  time_t then = time(NULL) - 1;
  ftp_set_close_handler();

  if (hookf)
    hookf(&ftp->ti);
  ftp->ti.begin = false;

  struct stat sb;
  errno = 0;
  if (fstat(fileno(fp), &sb) == -1)
  {
    ftp_err(_("Couldn't fstat local file: %s\n"), strerror(errno));
    ssh_scp_free(scp);
    return -1;
  }

  int rc = ssh_scp_push_file(scp, path, sb.st_size, sb.st_mode & (S_IRWXU | S_IRWXG | S_IRWXO));
  if (rc != SSH_OK)
  {
    ftp_err(_("Failed to start scp upload: %s\n"),
            ssh_get_error(ftp->session));
    ssh_scp_close(scp);
    ssh_scp_free(scp);
    return -1;
  }

  /* read file */
  char buffer[SSH_BUFSIZ];
  ssize_t nbytes = 0;
  errno = 0;
  while ((nbytes = fread(buffer, sizeof(char), sizeof(buffer), fp)) > 0)
  {
    if (ftp_sigints() > 0)
    {
      ftp_trace("break due to sigint\n");
      break;
    }

    rc = ssh_scp_write(scp, buffer, nbytes);
    if (rc != SSH_OK)
    {
      ftp_err(_("Error while writing to file: %s\n"), ssh_get_error(ftp->session));
      ssh_scp_close(scp);
      ssh_scp_free(scp);
      return -1;
    }

    ftp->ti.size += nbytes;
    if (hookf)
    {
      time_t now = time(NULL);
      if (now > then)
      {
        hookf(&ftp->ti);
        then = now;
      }
    }
    errno = 0;
  }

  if (ferror(fp))
  {
    ftp_err(_("Failed to read from file: %s\n"), strerror(errno));
    rc = -1;
  }

  ssh_scp_close(scp);
  ssh_scp_free(scp);
  return rc;
}