Using the os.FileMode Type in Go

Introduction
Prerequisites
Setting up Go
Overview of os.FileMode
Creating a File with Custom File Permissions
Modifying File Permissions
Reading File Permissions
Conclusion

Introduction

In Go, the os.FileMode type represents file permissions and mode bits. It is commonly used when creating, modifying, or reading file permissions in a Go program. This tutorial will delve into the os.FileMode type and demonstrate how to use it to set, modify, and read file permissions in a Go script. By the end of this tutorial, you will have a solid understanding of working with the os.FileMode type and how to manipulate file permissions programmatically in Go.

Prerequisites

To follow along with this tutorial, you should have a basic understanding of the Go programming language and have Go installed on your system.

Setting up Go

If you haven’t already installed Go, you can download and install it from the official Go website (https://golang.org). Follow the instructions specific to your operating system to complete the installation. Once Go is set up, ensure that you have the go command available in your terminal or command prompt.

To verify your installation and check the Go version, open a terminal window and run the following command:

go version

If Go is properly installed, you should see the installed version printed on the screen.

Overview of os.FileMode

The os.FileMode type is an alias for the uint32 type and represents file mode and permission bits in Go. Each bit within the os.FileMode corresponds to a different permission or file mode such as read, write, or execute. The os package in Go provides various constants to set different file modes and permissions.

Creating a File with Custom File Permissions

To create a file with custom file permissions using the os.FileMode type, follow these steps:

Create a new Go file, for example, main.go, and open it in your preferred text editor.

Import the necessary packages:

 package main
    
 import (
 	"fmt"
 	"os"
 )

In the main function, use the os.Create function to create a new file:

 func main() {
 	file, err := os.Create("example.txt")
 	if err != nil {
 		fmt.Println("Error creating file:", err)
 		return
 	}
 	defer file.Close()
 }

Set the file permissions using the Chmod function and provide a bitmask with the desired permissions:
```
 func main() {
 	// ...
    
 	err = file.Chmod(os.FileMode(0644))
 	if err != nil {
 		fmt.Println("Error setting file permissions:", err)
 		return
 	}
    
 	// ...
 }
```
In this example, we set the file permissions to 0644, which means the owner has read and write permissions (octal value 6), while the group and others have read-only permissions (octal value 4).
Save the file and navigate to the directory containing the main.go file in your terminal.
Build and run the Go program:
```
 go run main.go
```
This will create a file named example.txt with the specified file permissions.

Modifying File Permissions

To modify the file permissions of an existing file, you can use the Chmod function similarly to how it was used in the previous example. Here’s an example of how to modify the file permissions of an existing file:

func main() {
	file, err := os.OpenFile("example.txt", os.O_RDWR, 0644)
	if err != nil {
		fmt.Println("Error opening file:", err)
		return
	}
	defer file.Close()

	err = file.Chmod(os.FileMode(0600))
	if err != nil {
		fmt.Println("Error modifying file permissions:", err)
		return
	}
}

In this example, we open the existing file using os.OpenFile with the os.O_RDWR flag to allow both reading and writing. We then modify the file permissions to 0600, granting read and write permissions only to the file owner.

Reading File Permissions

To read the file permissions of a file, you can use the Stat function from the os package. Here’s an example of how to retrieve file permissions:

func main() {
	fileInfo, err := os.Stat("example.txt")
	if err != nil {
		fmt.Println("Error retrieving file information:", err)
		return
	}

	fileMode := fileInfo.Mode()
	permissions := fileMode.Perm()

	fmt.Printf("Permissions: %04o\n", permissions)
}

In this example, we use the Stat function to retrieve information about the file specified (example.txt). Then, we obtain the file mode using the Mode method of the os.FileInfo struct. Finally, we extract the file permissions using the Perm method of the os.FileMode type. The result is printed in octal format using the %04o format specifier.

Conclusion

In this tutorial, you learned how to use the os.FileMode type in Go to manipulate file permissions. You now understand how to create a file with custom file permissions, modify existing file permissions, and read file permissions using the os package in Go. Leveraging the os.FileMode type allows you to programmatically control file permissions within your Go scripts.

Published: 9 September 2019