Cfxtrjtrk

Another method is to copy using tar + ssh instead of scp:

tar -c -C ./my/local/dir 

  | ssh dimitris@myserver.com "sudo tar -x --no-same-owner -C /var/www"

You can also use ansible to accomplish this.

Copy to remote host using ansible's copy module:

ansible -i HOST, -b -m copy -a "src=SRC_FILEPATH dest=DEST_FILEPATH" all

Fetch from remote host using ansible's fetch module:

ansible -i HOST, -b -m fetch -a "src=SRC_FILEPATH dest=DEST_FILEPATH flat=yes" all

NOTE:

• The comma in the -i HOST, syntax is not a typo. It is the way to use ansible without needing an inventory file.


• 
  -b causes the actions on the server to be done as root. -b expands to --become, and the default --become-user is root, with the default --become-method being sudo.


• 
  flat=yes copies just the file, doesn't copy whole remote path leading to the file


• Using wildcards in the file paths isn't supported by these ansible modules.


• Copying a directory is supported by the copy module, but not by the fetch module.

Specific Invocation for this Question

Here's an example that is specific and fully specified, assuming the directory on your local host containing the files to be distributed is sourcedir, and that the remote target's hostname is hostname:

cd sourcedir && 

ansible 

   --inventory-file hostname,  

   --become 

   --become-method sudo 

   --become-user root 

   --module-name copy 

   --args "src=. dest=/var/www/" 

   all

With the concise invocation being:

cd sourcedir && 

ansible -i hostname, -b -m copy -a "src=. dest=/var/www/" all

P.S., I realize that saying "just install this fabulous tool" is kind of a
tone-deaf answer. But I've found ansible to be super useful for administering remote servers, so installing it will surely bring you other benefits beyond deploying files.

Quick way

From server to local machine:

ssh user@server "sudo cat /etc/dir/file" > /home/user/file

From local machine to server:

cat /home/user/file | ssh user@server "sudo tee -a /etc/dir/file"

When you run sudo su, any files you create will be owned by root, but it is not possible by default to directly log in as root with ssh or scp. It is also not possible to use sudo with scp, so the files are not usable. Fix this by claiming ownership over your files:

Assuming your user name was dimitri, you could use this command.

sudo chown -R dimitri:dimitri /home/dimitri

From then on, as mentioned in other answers, the "Ubuntu" way is to use sudo, and not root logins. It is a useful paradigm, with great security advantages.

May be the best way is to use rsync (Cygwin/cwRsync in Windows) over SSH?

For example, to upload files with owner www-data:

rsync -a --rsync-path="sudo -u www-data rsync" path_to_local_data/ login@srv01.example.com:/var/www

In your case, if you need root privileges, command will be like this:

rsync -a --rsync-path="sudo rsync" path_to_local_data/ login@srv01.example.com:/var/www

See: scp to remote server with sudo.

If you use the OpenSSH tools instead of PuTTY, you can accomplish this by initiating the scp file transfer on the server with sudo. Make sure you have an sshd daemon running on your local machine. With ssh -R you can give the server a way to contact your machine.

On your machine:

ssh -R 11111:localhost:22 REMOTE_USERNAME@SERVERNAME

In addition to logging you in on the server, this will forward every connection made on the server's port 11111 to your machine's port 22: the port your sshd is listening on.

On the server, start the file transfer like this:

cd /var/www/

sudo scp -P 11111 -r LOCAL_USERNAME@localhost:FOLDERNAME .

You may use script I've written being inspired by this topic:

touch /tmp/justtest && scpassudo /tmp/justtest remoteuser@ssh.superserver.com:/tmp/

but this requires some crazy stuff (which is btw. automatically done by script)

1. server which file is being sent to will no longer ask for password while establishing ssh connection to source computer


2. due to necessarility of lack of sudo prompt on the server, sudo will no longer ask for password on remote machine, for user

Here goes the script:

interface=wlan0

if [[ $# -ge 3 ]]; then interface=$3; fi

thisIP=$(ifconfig | grep $interface -b1 | tail -n1 | egrep -o '[0-9.]{4,}' -m1 | head -n 1)

thisUser=$(whoami)

localFilePath=/tmp/justfortest

destIP=192.168.0.2

destUser=silesia

#dest 

#destFolderOnRemoteMachine=/opt/glassfish/glassfish/

#destFolderOnRemoteMachine=/tmp/



if [[ $# -eq 0 ]]; then 

echo -e "Send file to remote server to locatoin where root permision is needed.ntusage: $0 local_filename [username@](ip|host):(remote_folder/|remote_filename) [optionalInterface=wlan0]"

echo -e "Example: nttouch /tmp/justtest &&nt $0 /tmp/justtest remoteuser@ssh.superserver.com:/tmp/ "

exit 1

fi



localFilePath=$1



test -e $localFilePath 



destString=$2

usernameAndHost=$(echo $destString | cut -f1 -d':')



if [[ "$usernameAndHost" == *"@"* ]]; then

destUser=$(echo $usernameAndHost | cut -f1 -d'@')

destIP=$(echo $usernameAndHost | cut -f2 -d'@')

else

destIP=$usernameAndHost

destUser=$thisUser

fi



destFolderOnRemoteMachine=$(echo $destString | cut -f2 -d':')



set -e #stop script if there is even single error



echo 'First step: we need to be able to execute scp without any user interaction'

echo 'generating public key on machine, which will receive file'

ssh $destUser@$destIP 'test -e ~/.ssh/id_rsa.pub -a -e ~/.ssh/id_rsa || ssh-keygen -t rsa'

echo 'Done'



echo 'Second step: download public key from remote machine to this machine so this machine allows remote machine (this one receiveing file) to login without asking for password'



key=$(ssh $destUser@$destIP 'cat ~/.ssh/id_rsa.pub')

if ! grep "$key" ~/.ssh/authorized_keys; then

echo $key >> ~/.ssh/authorized_keys

echo 'Added key to authorized hosts'

else

echo "Key already exists in authorized keys"

fi



echo "We will want to execute sudo command remotely, which means turning off asking for password"

echo 'This can be done by this tutorial http://stackoverflow.com/a/10310407/781312'

echo 'This you have to do manually: '

echo -e "execute in new terminal: ntssh $destUser:$destIPnPress enter when ready"

read 

echo 'run there sudo visudo'

read

echo 'change '

echo '    %sudo   ALL=(ALL:ALL) ALL'

echo 'to'

echo '    %sudo   ALL=(ALL:ALL) NOPASSWD: ALL'

echo "After this step you will be done."

read



listOfFiles=$(ssh $destUser@$destIP "sudo ls -a")



if [[ "$listOfFiles" != "" ]]; then 

echo "Sending by executing command, in fact, receiving, file on remote machine"

echo 'Note that this command (due to " instead of '', see man bash | less -p''quotes'') is filled with values from local machine'

echo -e "Executing nt""identy=~/.ssh/id_rsa; sudo scp -i $identy $(whoami)@$thisIP:$(readlink -f $localFilePath) $destFolderOnRemoteMachine"" non remote machine"

ssh $destUser@$destIP "identy=~/.ssh/id_rsa; sudo scp -i $identy $(whoami)@$thisIP:$(readlink -f $localFilePath) $destFolderOnRemoteMachine"

ssh $destUser@$destIP "ls ${destFolderOnRemoteMachine%\\n}/$(basename $localFilePath)"

if [[ ! "$?" -eq 0 ]]; then echo "errror in validating"; else echo -e "SUCCESS! Successfully sentnt$localFilePath nto nt$destStringnFind more at http://arzoxadi.tk"; fi

else

echo "something went wrong with executing sudo on remote host, failure"



fi

ENDOFSCRIPT

) | sudo tee /usr/bin/scpassudo && chmod +x /usr/bin/scpassudo

You can combine ssh, sudo and e.g tar to transfer files between servers without being able to log in as root and not having the permission to access the files with your user. This is slightly fiddly, so I've written a script to help this. You can find the script here: https://github.com/sigmunau/sudoscp

or here:

#! /bin/bash

res=0

from=$1

to=$2

shift

shift

files="$@"

if test -z "$from" -o -z "$to" -o -z "$files"

then

    echo "Usage: $0    (file)*"

    echo "example: $0 server1 server2 /usr/bin/myapp"

    exit 1

fi



read -s -p "Enter Password: " sudopassword

echo ""

temp1=$(mktemp)

temp2=$(mktemp)

(echo "$sudopassword";echo "$sudopassword"|ssh $from sudo -S tar c -P -C / $files 2>$temp1)|ssh $to sudo -S tar x -v -P -C / 2>$temp2

sourceres=${PIPESTATUS[0]}

if [ $? -ne 0 -o $sourceres -ne 0 ]

then

    echo "Failure!" >&2

    echo "$from output:" >&2

    cat $temp1 >&2

    echo "" >&2

    echo "$to output:" >&2

    cat $temp2 >&2

    res=1

fi



rm $temp1 $temp2

exit $res

Here's a modified version of Willie Wheeler's answer that transfers the file(s) via tar but also supports passing a password to sudo on the remote host.

(stty -echo; read passwd; stty echo; echo $passwd; tar -cz foo.*) 

  | ssh remote_host "sudo -S bash -c "tar -C /var/www/ -xz; echo""

The little bit of extra magic here is the -S option to sudo. From the sudo man page:

-S, --stdin
Write the prompt to the standard error and read the password from the standard input instead of using the terminal device. The password must be followed by a newline character.

Now we actually want the output of tar to be piped into ssh and that redirects the stdin of ssh to the stdout of tar, removing any way to pass the password into sudo from the interactive terminal. (We could use sudo's ASKPASS feature on the remote end but that is another story.) We can get the password into sudo though by capturing it in advance and prepending it to the tar output by performing those operations in a subshell and piping the output of the subshell into ssh. This also has the added advantage of not leaving an environment variable containing our password dangling in our interactive shell.

You'll notice I didn't execute 'read' with the -p option to print a prompt. This is because the password prompt from sudo is conveniently passed back to the stderr of our interactive shell via ssh. You might wonder "how is sudo executing given it is running inside ssh to the right of our pipe?" When we execute multiple commands and pipe the output of one into another, the parent shell (the interactive shell in this case) executes each command in the sequence immediately after executing the previous. As each command behind a pipe is executed the parent shell attaches (redirects) the stdout of the left-hand side to the stdin of the right-hand side. Output then becomes input as it passes through processes. We can see this in action by executing the entire command and backgrounding the process group (Ctrl-z) before typing our password, and then viewing the process tree.

$ (stty -echo; read passwd; stty echo; echo $passwd; tar -cz foo.*) | ssh 

remote_host "sudo -S bash -c "tar -C /var/www/ -xz; echo""

[sudo] password for bruce: 

[1]+  Stopped                 ( stty -echo; read passwd; stty echo; echo 

$passwd; tar -cz foo.* ) | ssh remote_host "sudo -S bash -c "tar -C 

/var/www/ -xz; echo""



$ pstree -lap $$

bash,7168

  ├─bash,7969

  ├─pstree,7972 -lap 7168

  └─ssh,7970 remote_host sudo -S bash -c "tar -C /var/www/ -xz; echo"`

Our interactive shell is PID 7168, our subshell is PID 7969 and our ssh process is PID 7970.

The only drawback is that read will accept input before sudo has time to send back it's prompt. On a fast connection and fast remote host you won't notice this but you might if either is slow. Any delay will not affect the ability to enter the prompt; it just might appear after you have started typing.

Note I simply added a host file entry for "remote_Host" to my local machine for the demo.