How does one contract send ether to another contract with more than 2300 gas?

Question

I want one contract to collect a certain amount of finney before sending it to another contract, but I can't simply send in with C2.send(thisMuch).

function() {
    Dividend m = Dividend(dividendAddr);
    if (this.balance >= 70 finney) {
        uint sendProfit = this.balance;
    }
    m.Enter.send(sendProfit);
}

This is what I have so far, but I'm completely lost when it comes to sending finney from one contract to the next. How can I do that?

I have made two contracts on how I think it should work. Contract one sends it to contract two.

contract one {

    address public deployer;
    address public targetAddress;


    modifier execute {
        if (msg.sender == deployer) {
            _
        }
    }


    function one(address _targetAddress) {
        deployer = msg.sender;
        targetAddress = _targetAddress;
    }


    function forward() {
        two m = two(targetAddress);
        m.pay();
        targetAddress.send(this.balance);
    }


    function() {
        forward();
    }


    function sendBack() execute {
        deployer.send(this.balance);
    }


}

Contract two sends it back to me.

contract two {

    address public deployer;

    function two() {
        deployer = msg.sender;
    }

    function pay() {
        deployer.send(this.balance);
    }

    function() {
        pay();
    }

}

Is this how it should work?

Answer 1

In order to send Ether to another contract while specifying the amount of gas, use the call function.

targetAddress.call.gas(200000).value(this.balance)(); will call the fallback function.

targetAddress.call.gas(200000).value(this.balance)(bytes4(sha3("pay()"))); will call the pay function.

Answer 2

It should be possible to specify the transmitted value and used gas for each external function (and constructor) call:

contract Fa { function fa(uint _a) {} }

contract Fb {
  function fb(address a) {
     Fa b= Fa(a);// or Fa b = New Fa.value(2).gas(200)(a);
    b.fa.value(3).gas(1500)(50);
  }
}

f.gas(x).value(20)() calls the modified function f and thereby sending 20 Wei (or 20 ether by value(20 ether)) and limiting the gas to x (so this function call will most likely go out of gas and return your 20 Wei).

NB : send() should actually use min gas. If we want the code to be executed, we should use call()

Answer 3

Calling external functions is documented here. To the best of my knowledge, there's no way to send to the default function with a user-specified amount of gas; you have to call a named function.

Answer 4

Functions that send Ether shall be marked as payable: function name(args) payable { //do something }