Page History

Methods can return values to signify communicate failure or success , at other times, or to update the caller's local objects or fields. Security risks can arise if when method return values are simply ignored or if when the invoking method fails to take suitable action is not taken on their receipt.

Non-Compliant Code Example

. Consequently, programs must not ignore method return values.

When getter methods are named after an action, a programmer could fail to realize that a return value is expected. For example, the only purpose of the ProcessBuilder.redirectErrorStream() method is to report via return value whether the process builder successfully merged standard error and standard output. The method that actually performs redirection of the error stream is the overloaded single-argument method ProcessBuilder.redirectErrorStream(boolean).

Noncompliant Code Example (File Deletion)

This noncompliant code example attempts to delete a file but fails to check whether the operation has succeeded:

public void deleteFile(){

  File someFile = new File("someFileName.txt");
  // Do something with someFile
  someFile.delete();

}

Compliant Solution

This compliant solution checks the Boolean value returned by the delete() method and handles any resulting errors:

public void deleteFile(){

  File someFile = new File("someFileName.txt");
  // Do something with someFile
  if (!someFile.delete()) {
    // Handle failure to delete the file
  }

}

Noncompliant Code Example (String Replacement)

This noncompliant This non-compliant code example ignores the return value while making use of the String.replace() method. As a result, the original string is not updated even though it seems otherwise, failing to update the original string. The String.replace() method cannot modify the state of the String (because String objects are immutable); rather, it returns a reference to a new String object containing the modified string.

public class IgnoreReplace {
  public static void main(String[] args) {
    String original = "insecure";
    original.replace( 'i', '9' );
    System.out.println (original);
  }
}

It is especially important to process the return values of immutable object methods. Although many methods of mutable objects operate by changing some internal state of the object, methods of immutable objects cannot change the object and often return a mutated new object, leaving the original object unchanged.

Compliant Solution

The This compliant solution correctly updates the original string object by assigning to it String reference original with the return value from the String.replace() method:

public class DoNotIgnoreReplace {
  public static void main(String[] args) {
    String original = "insecure";
    original = original.replace( 'i', '9' );
    System.out.println (original);
  }
}

References

Risk Assessment

Ignoring method return values can lead to unexpected program behavior.

Automated Detection

Related Guidelines

Bibliography

[API 2006]	method delete() method replace()
[Green 2008]	String.replace
[Pugh 2009]	Misusing putIfAbsent
[Seacord 2015]	Image Added EXP00-J. Do not ignore values returned by methods LiveLesson

...

Image Added Image Added Image AddedCanadian Mind Products Java & Internet Glossary by Roedy Green "String.replace" http://mindprod.com/jgloss/gotchas.html^{Image Removed}
API String.replace http://java.sun.com/j2se/1.4.2/docs/api/java/lang/String.html^{Image Removed}