当前位置： 首页 > news >正文

CTF-RE 从0到N 1-1-1 开始之前-c函数手册

news 2024/10/25 15:26:09

gets

char *gets(char *s);

其中 s 是一个指向字符数组的指针,用于存储读取到的字符串。

gets() 函数有以下特点:

  1. 它会一直读取数据,直到遇到换行符(\n)或者文件结束符(EOF)为止。
  2. 它不会检查输入字符串的长度,因此容易产生缓冲区溢出漏洞。
  3. 它不会在结尾添加null终止符(\0)。

__readfsqword

通常用于栈金丝雀检测

setbuf

setvbuf 是 C 标准库中的一个函数，用于设置文件流的缓冲区属性。它允许程序员控制输入/输出操作时的缓冲行为，从而优化性能，特别是在频繁进行读写操作的情况下。

int setvbuf(FILE *stream, char *buf, int mode, size_t size);

参数说明

  • stream: 指向 FILE 对象的指针，该对象表示要设置缓冲区的文件流。
  • buf: 指向自定义缓冲区的指针。如果这个参数为 NULL，则 setvbuf 会为流分配一个内部的缓冲区。
  • mode: 缓冲模式，可以是以下常量之一：
    • _IOFBF：全缓冲（full buffering），只有在缓冲区满或者文件流被显式刷新时，才会将数据写入文件。
    • _IOLBF：行缓冲（line buffering），在遇到换行符或缓冲区满时，才会将数据写入文件。
    • _IONBF：无缓冲（no buffering），即每次写入操作都会立即写入文件。
  • size: 缓冲区的大小（以字节为单位）。如果 buf 为 NULL，这个参数将决定内部缓冲区的大小。

返回值

  • 如果成功，setvbuf 返回 0。
  • 如果失败，返回非零值（通常是 EOF），并且错误状态可能会设置。

__isoc99_scanf

__isoc99_scanf 是 C 语言标准库中的一个函数，通常是 scanf 函数的一个实现或内部版本。它用于从标准输入读取格式化的数据。__isoc99_scanf 是 GNU C 库和某些其他 C 标准库实现中的一个名称，主要用于在 C99 标准中提供与 scanf 兼容的接口。

int __isoc99_scanf(const char *format, ...);

参数说明

  • format: 一个格式字符串，指定输入数据的格式。例如，"%d" 用于读取整数，"%f" 用于读取浮点数，"%s" 用于读取字符串等。
  • …: 可变参数列表，根据格式字符串中指定的格式，提供对应的变量地址，以便存储读取的值。

返回值

  • __isoc99_scanf 返回成功读取并赋值的输入项的数量。如果没有成功读取任何项，则返回 EOF

snprintf

snprintf 是 C 语言中的一个标准库函数，用于格式化输出字符串。它的主要作用是将格式化的数据输出到一个字符数组中，同时可以指定输出的最大字符数，从而避免缓冲区溢出的问题。

函数原型

int snprintf(char *str, size_t size, const char *format, ...);

参数说明

  1. char *str: 输出字符串的目标缓冲区（字符数组）。
  2. size_t size: 目标缓冲区的大小，表示可以写入的最大字符数（包括结束符 \0）。
  3. const char *format: 格式控制字符串，类似于 printf 中的格式化字符串。
  4. ...: 可变参数列表，与格式控制字符串中的占位符相对应的值。

返回值

  • 返回实际写入 str 的字符数（不包括结尾的 \0）。
  • 如果返回值大于或等于 size，则表示输出被截断，实际写入的字符数超过了指定的大小。
  • 如果发生错误，返回一个负值。

使用示例

#include <stdio.h>int main() {char buffer[50];int written;written = snprintf(buffer, sizeof(buffer), "Hello, %s! You are %d years old.", "Alice", 30);if (written >= sizeof(buffer)) {printf("Output was truncated! Written: %d\n", written);} else {printf("Formatted string: %s\n", buffer);}return 0;
}

注意事项

  • 安全性: 使用 snprintf 可以避免缓冲区溢出，这是因为它允许你限制写入的字符数。
  • 终止符: 如果输出被截断，snprintf 仍然会在 str 的末尾添加 \0 终止符，确保字符串的正确性。
  • 性能: snprintf 的性能可能略低于 sprintf，因为它需要检查写入的字符数。

总结

snprintf 是一个非常有用的函数，适合用于需要格式化字符串并确保不发生缓冲区溢出的场景。它在开发高安全性应用程序时是一个推荐的选择。

strcat

strcat 是 C 标准库中的一个字符串处理函数，用于将两个字符串连接在一起。它把第二个字符串添加到第一个字符串的末尾，并在结果字符串的末尾自动添加一个 null 终止符（'\0'）。

char *strcat(char *dest, const char *src);

参数说明

  • dest: 目标字符串，表示要连接到的字符串。它必须有足够的空间来容纳连接后的结果。
  • src: 源字符串，表示要添加到目标字符串末尾的字符串。

返回值

  • strcat 返回一个指向目标字符串 dest 的指针。

read

read 函数是 C 语言中用于从文件描述符读取数据的系统调用。在 UNIX/Linux 系统中，read 函数通常用于从文件、设备或管道读取字节。

函数原型

#include <unistd.h>
ssize_t read(int fd, void *buf, size_t count);

参数说明

  • fd: 文件描述符，是一个整数，表示要读取的目标文件或设备。通过 open 函数打开文件后，会返回一个文件描述符。

      • 0: 标准输入（STDIN）
        通常用于接收输入数据，例如键盘输入。
    • 1: 标准输出（STDOUT）
      通常用于输出数据，例如终端或屏幕输出。
    • 2: 标准错误（STDERR）
      通常用于输出错误信息。

  • buf: 指向一个内存区域的指针，用于存放从文件描述符读取到的数据。

  • count: 要读取的字节数，表示希望读取的最大字节数。

返回值

  • 成功时，返回实际读取的字节数。
  • 如果返回值为 0，表示已到达文件末尾（EOF）。
  • 如果返回值为 -1，表示发生错误，错误信息可以通过 errno 变量获得。

示例代码

下面是一个使用 read 函数的简单示例，演示如何从文件中读取数据：

#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <fcntl.h>
#include <errno.h>#define BUFFER_SIZE 1024int main() {int fd;ssize_t bytesRead;char buffer[BUFFER_SIZE];// 打开文件fd = open("example.txt", O_RDONLY);if (fd == -1) {perror("Error opening file");return EXIT_FAILURE;}// 读取文件内容while ((bytesRead = read(fd, buffer, sizeof(buffer))) > 0) {// 写入标准输出write(STDOUT_FILENO, buffer, bytesRead);}// 检查读取是否出现错误if (bytesRead == -1) {perror("Error reading file");close(fd);return EXIT_FAILURE;}// 关闭文件描述符close(fd);return EXIT_SUCCESS;
}

注意事项

  1. 文件描述符: 使用 read 之前，确保文件已成功打开，并获得有效的文件描述符。
  2. 阻塞与非阻塞: read 函数在默认情况下是阻塞的，意味着如果没有数据可读，它会等待数据到达。
  3. 缓冲区大小: 读取的字节数不一定等于请求的字节数，实际返回的字节数由 read 函数返回值决定。
  4. 错误处理: 使用 perror 或检查 errno 以处理可能的错误。

write

ssize_t write(int fd, const void *buf, size_t count);

参数说明

  • fd: 文件描述符，表示要写入的目标。可以是标准输出（通常是 1）、标准错误（通常是 2）或打开的文件的描述符。
  • buf: 指向要写入的数据缓冲区的指针。可以是任意类型的指针，但通常是 char* 类型。
  • count: 要写入的字节数，指定从缓冲区中要写入的字节数。

返回值

  • 返回成功写入的字节数。如果写入过程中发生错误，则返回 -1，并且 errno 将被设置为相应的错误代码。
  • 注意：返回的字节数可能小于 count，这在写入非阻塞文件描述符时（如某些设备或套接字）可能会发生。

mmap

void *mmap(void *addr, size_t length, int prot, int flags, int fd, off_t offset);

参数

  • addr：

    • 指定映射区的首地址。通常设置为NULL，让内核选择合适的地址。

  • length：

    • 映射区的长度（字节数）。映射的文件内容从offset开始，长度为length。

  • prot：

    • 映射区的保护权限。常见的选项包括：
      • PROT_READ：可读
      • PROT_WRITE：可写
      • PROT_EXEC：可执行
      • PROT_NONE：不可访问

  • flags：

    • 映射的类型和属性。常见的标志有：
      • MAP_SHARED：映射区的数据会和其他映射相同文件的进程共享。对映射区的修改会同步到文件中。
      • MAP_PRIVATE：私有映射。对映射区的修改不会影响到原文件。
      • MAP_ANONYMOUS：匿名映射，不与文件关联（fd参数应设为-1，并且不需要提供offset）。

  • fd：

    • 打开文件的文件描述符。如果使用匿名映射（MAP_ANONYMOUS），则fd应设为-1。

  • offset：

    • 文件中映射的起始位置，必须是分页大小（通常是4KB）的整数倍。

返回值

  • 成功时，mmap()返回映射区的起始地址。
  • 失败时，返回MAP_FAILED（通常是(void *)-1），并设置errno以指示错误原因。

使用场景

  1. 文件映射：将文件的一部分映射到内存中，可以像操作内存一样操作文件的内容。适用于大文件处理。

  2. 共享内存：通过MAP_SHARED标志，不同进程可以共享内存数据。

  3. 匿名映射：用于进程间通信或分配大块内存。

open / close

int open(const char *pathname, int flags, mode_t mode);

参数：

  • pathname：

    • 要打开的文件路径。

  • flags：

    • 文件的打开模式，控制文件的读写方式以及文件是否创建等。常用的标志包括：
      • O_RDONLY：只读模式。
      • O_WRONLY：只写模式。
      • O_RDWR：读写模式。
      • O_CREAT：如果文件不存在则创建文件（需要提供mode参数）。
      • O_TRUNC：如果文件存在，则将文件长度截断为0。
      • O_APPEND：写入数据时总是追加到文件末尾。

  • mode：

    • 文件创建时的权限模式，仅在O_CREAT标志被设置时使用。常见的权限模式包括：
      • S_IRUSR：用户读取权限。
      • S_IWUSR：用户写入权限。
      • S_IXUSR：用户执行权限。
      • S_IRGRP：组读取权限。
      • S_IWGRP：组写入权限。
      • S_IROTH：其他人读取权限。

返回值：

  • 成功时，返回一个非负整数，表示文件描述符。
  • 失败时，返回-1，并设置errno以指示错误原因。
int close(int fd);

参数：

  • fd：
    • 需要关闭的文件描述符，由open()函数返回。

返回值：

  • 成功时，返回0。
  • 失败时，返回-1，并设置errno以指示错误原因。

memset

emset 是 C 标准库中的一个函数，用于将某一块内存区域的值设置为指定的值。它通常用于初始化内存，尤其是在分配内存之后或重置结构体和数组时。

其函数原型如下：

void *memset(void *s, int c, size_t n);

参数说明：

  • s：指向需要设置的内存区域的指针。
  • c：要填充到内存中的值。注意，该值会被转换为 unsigned char 类型。
  • n：需要设置的字节数，即从指针 s 开始的内存区域的大小。

返回值：

memset 返回指向 s 的指针，即它会返回传入的内存区域的地址。

作用：

memset 函数将从指针 s 开始的连续 n 个字节的内存区域设置为值 c。该值会被强制转换为 unsigned char 类型（即一个字节大小），然后复制到内存中的每个字节。

strcpy

strcpy 是 C 标准库中的一个字符串处理函数，用于将一个字符串复制到另一个字符串中。这个函数非常常用，但由于其安全性问题，在使用时需要特别小心。

函数原型

char *strcpy(char *dest, const char *src);

参数说明

  1. char *dest:

    • 目标字符串的指针，src 字符串将被复制到这里。dest 需要有足够的空间来存储 src 字符串及其结束符 '\0'。

  2. const char *src:

    • 源字符串的指针，要复制的字符串。

返回值

  • strcpy 返回指向目标字符串 dest 的指针，即 dest 自身。

特点

  • strcpy 会将源字符串 src 中的所有字符（包括结束符 '\0'）复制到目标字符串 dest 中。
  • 如果 dest 的内存空间不足以容纳 src，将导致缓冲区溢出，这可能会导致未定义行为，甚至崩溃。

示例代码

以下是一个简单的示例，演示如何使用 strcpy 函数：

#include <stdio.h>
#include <string.h>int main() {char src[] = "Hello, World!";char dest[50];  // 确保目标数组有足够的空间// 复制字符串strcpy(dest, src);// 输出结果printf("源字符串: %s\n", src);printf("目标字符串: %s\n", dest);return 0;
}

输出示例

运行上面的程序将输出：

源字符串: Hello, World!
目标字符串: Hello, World!

安全性考虑

由于 strcpy 不会检查目标缓冲区的大小，使用它可能会导致缓冲区溢出。为了提高代码的安全性，建议使用 strncpy 或 strlcpy（如果可用）等更安全的替代方案。

strncpy 示例

strncpy 函数可以指定要复制的最大字符数，从而避免缓冲区溢出的问题：

#include <stdio.h>
#include <string.h>int main() {char src[] = "Hello, World!";char dest[10];// 复制字符串，限制最大字符数为9，留一个位置给 '\0'strncpy(dest, src, sizeof(dest) - 1);dest[sizeof(dest) - 1] = '\0';  // 确保字符串以 '\0' 结尾printf("目标字符串: %s\n", dest);return 0;
}

strncpy

strncpy 是 C 标准库中的一个函数，用于将一个字符串复制到另一个字符串中。与 strcpy 不同，strncpy 允许你指定要复制的字符数量，从而提供了更好的安全性来防止缓冲区溢出。

函数原型

char *strncpy(char *dest, const char *src, size_t n);

参数说明

  1. char *dest:

    • 目标字符串的指针，src 字符串将被复制到这里。需要确保 dest 有足够的空间来存储 src 的内容。

  2. const char *src:

    • 源字符串的指针，要复制的字符串。

  3. size_t n:

    • 指定要复制的最大字符数。如果 src 的长度小于 n，则 strncpy 会在 dest 中填充剩余的空间，直到达到 n 个字符。

返回值

  • strncpy 返回指向目标字符串 dest 的指针，即 dest 自身。

特点

  • strncpy 会从 src 中复制最多 n 个字符到 dest 中。
  • 如果 src 的长度小于 n，则 dest 中的剩余空间将被填充为 '\0'，但这并不一定是自动的。如果 src 的长度大于或等于 n，则 dest 不会以 '\0' 结尾。
  • 使用 strncpy 时，确保目标缓冲区有足够的空间来容纳复制的内容和可能的结束符。

示例代码

以下是一个简单的示例，演示如何使用 strncpy 函数：

#include <stdio.h>
#include <string.h>int main() {char src[] = "Hello, World!";char dest[20];  // 确保目标数组有足够的空间// 复制字符串，指定最大字符数strncpy(dest, src, sizeof(dest) - 1);dest[sizeof(dest) - 1] = '\0';  // 确保字符串以 '\0' 结尾// 输出结果printf("源字符串: %s\n", src);printf("目标字符串: %s\n", dest);return 0;
}

输出示例

运行上面的程序将输出：

源字符串: Hello, World!
目标字符串: Hello, World!

注意事项

  1. 字符串未以 '\0' 结尾：

    • 如果 src 的长度大于或等于指定的 n，则 dest 不会以 '\0' 结尾。因此，在使用 strncpy 时，确保手动在目标字符串末尾添加 '\0'，以避免未定义行为。

  2. 安全性：

    • strncpy 在某种程度上比 strcpy 更安全，因为它允许开发者控制复制的字符数量，从而减少缓冲区溢出的风险。然而，如果不正确使用，仍然可能导致安全问题。

  3. 性能：

    • 由于 strncpy 可能会在填充零字符时遍历整个目标缓冲区，因此它在某些情况下可能比 strcpy 更慢。

总结

strncpy 是一个用于安全复制字符串的函数，通过限制复制字符的数量来减少缓冲区溢出的风险。然而，使用时需要特别注意可能导致字符串未以 '\0' 结尾的问题。确保了解其使用方法和潜在的陷阱，对于编写安全和可靠的 C 代码至关重要。如果你有其他问题或需要更深入的解释，请随时提问！

qmemcpy

qmemcpy 是一个在某些 C/C++ 环境中使用的函数，通常用于高效地复制内存块。尽管 qmemcpy 不是 C 标准库的一部分，但它的命名和功能通常与内存复制相关。下面是对 qmemcpy 函数可能的实现和功能的解释。

功能概述

qmemcpy 的主要功能是将一块内存从源地址复制到目标地址，类似于标准库中的 memcpy 函数。它通常用于处理二进制数据，例如在图形处理、网络编程或大数据处理等领域。

可能的函数签名

虽然不同的实现可能会有不同的参数，常见的 qmemcpy 函数的签名可能如下：

void* qmemcpy(void* dest, const void* src, size_t n);

参数说明

  • dest：目标内存地址，即要将数据复制到的地方。
  • src：源内存地址，即要从中复制数据的地方。
  • n：要复制的字节数。

返回值

  • 返回指向目标内存的指针 dest。

典型实现

一个简单的 qmemcpy 实现可能如下：

#include <stddef.h>void* qmemcpy(void* dest, const void* src, size_t n) {char* d = (char*)dest;const char* s = (const char*)src;// 逐字节复制while (n--) {*d++ = *s++;}return dest;
}

注意事项

  • 重叠内存：如果源和目标内存区域重叠，qmemcpy 的行为可能未定义。为了安全地处理重叠内存，可以考虑使用 memmove 函数。

  • 性能：在某些情况下，qmemcpy 的实现可能会比标准 memcpy 更快，尤其是在特定的硬件或特定的内存布局下，但这取决于具体的实现。

  • 类型安全：与许多 C 函数一样，使用 qmemcpy 时需要确保传递的指针是有效的，并且指定的长度 n 不会导致超出目标缓冲区的访问。

结论

qmemcpy 是一个用于内存复制的函数，虽然它不是 C 标准库的一部分，但在某些项目或库中可能会被定义。它的主要作用是将一块内存从源位置复制到目标位置。使用时应注意内存重叠和类型安全问题。如果你在使用一个特定的库或框架，建议查看其文档以获取关于 qmemcpy 的具体实现和用法。

memcmp

memcmp 是一个在 C 和 C++ 标准库中定义的函数，用于比较两块内存区域的内容。它通常用于二进制数据的比较，比如在处理字符串或其他数据结构时。

函数原型

在 C 中，memcmp 的函数原型如下：

int memcmp(const void *ptr1, const void *ptr2, size_t num);

参数

  • const void *ptr1: 指向要比较的第一块内存区域的指针。
  • const void *ptr2: 指向要比较的第二块内存区域的指针。
  • size_t num: 要比较的字节数。

返回值

memcmp 函数会根据比较结果返回一个整数值：

  • 负值: 如果第一块内存区域的内容小于第二块内存区域的内容。
  • 零: 如果两块内存区域的内容相等。
  • 正值: 如果第一块内存区域的内容大于第二块内存区域的内容。

功能

memcmp 函数逐字节比较 ptr1 和 ptr2 指向的内存区域的前 num 字节。比较的过程是按字节进行的，不会考虑数据的类型或结构，只是简单地比较每个字节的值。

使用示例

下面是一个使用 memcmp 的简单示例：

#include <stdio.h>
#include <string.h>int main() {const char *str1 = "abc";const char *str2 = "abd";int result = memcmp(str1, str2, 3); // 比较前3个字节if (result < 0) {printf("str1 < str2\n");} else if (result > 0) {printf("str1 > str2\n");} else {printf("str1 == str2\n");}return 0;
}

注意事项

  1. 未定义行为: 如果 ptr1 和 ptr2 指向的内存区域重叠，memcmp 的行为是未定义的。在这种情况下，应使用 memmove 来处理可能重叠的内存区域。

  2. 比较的字节数: num 参数指定要比较的字节数。如果 num 超过了实际的内存大小，可能导致访问越界，从而导致未定义行为或程序崩溃。

  3. 用途: memcmp 通常用于比较二进制数据，适用于字符串、数组、结构体等类型的数据。对于字符串的比较，通常更推荐使用 strcmp，因为它是为字符串设计的，能够正确处理字符串终止符。

总结

memcmp 是一个用于比较两块内存区域的有用函数，它在许多编程情况下都非常实用，尤其是在处理低级数据和二进制文件时。正确使用 memcmp 可以帮助开发者有效地进行内存内容的比较。

strncmp

strncmp 是 C 标准库中的一个函数，用于比较两个字符串的前 n 个字符。与 strcmp 不同的是，strncmp 会在比较过程中最多只比较前 n 个字符。

其函数原型如下：

int strncmp(const char *s1, const char *s2, size_t n);

参数说明：

  • s1：指向要比较的第一个字符串。
  • s2：指向要比较的第二个字符串。
  • n：指定要比较的字符数。

返回值：

  • 如果 s1 和 s2 在前 n 个字符中相等，则返回 0。
  • 如果 s1 在前 n 个字符中小于 s2，则返回一个小于 0 的值。
  • 如果 s1 在前 n 个字符中大于 s2，则返回一个大于 0 的值。

作用：

strncmp 函数会逐个比较 s1 和 s2 的前 n 个字符，直到发现不同的字符，或者其中一个字符串结束。比较时按照 ASCII 值进行。

execve

execve 是一个在 Unix 和类 Unix 操作系统中用于执行程序的系统调用。它的全名是 “execute program” 的缩写。execve 函数用于加载并执行指定的程序，并替换当前进程的映像（memory image）。这是一个非常底层的系统调用，通常用于实现其他更高级的进程创建和执行功能。

函数原型

int execve(const char *pathname, char *const argv[], char *const envp[]);

参数

  1. pathname:

    • 指向要执行的程序的路径的字符串。这个路径可以是绝对路径或相对路径。

  2. argv:

    • 一个指向字符串数组的指针，该数组包含传递给新程序的命令行参数。第一个元素通常是程序的名称，最后一个元素必须是 NULL。

  3. envp:

    • 一个指向字符串数组的指针，该数组包含环境变量。每个环境变量都是一个 key=value 形式的字符串。最后一个元素也必须是 NULL。

返回值

  • 如果 execve 成功执行，函数不会返回，因为当前进程的映像被新程序替换。
  • 如果发生错误，execve 将返回 -1，并设置 errno 以指示错误类型。

常见错误

  • ENOENT: 指定的程序文件不存在。
  • EACCES: 文件存在，但当前用户没有执行权限。
  • ENOMEM: 内存不足，无法分配所需的资源。

使用示例

以下是一个简单的使用 execve 的示例：

#include <unistd.h>
#include <stdio.h>int main() {char *argv[] = { "ls", "-l", NULL };  // 参数数组char *envp[] = { "HOME=/usr/home", "USER=user", NULL };  // 环境变量数组// 执行 ls 命令if (execve("/bin/ls", argv, envp) == -1) {perror("execve");  // 如果 execve 失败，打印错误信息}return 0;  // 这行代码在 execve 成功时永远不会被执行
}

使用场景

  • execve 通常在需要执行新程序的情境中使用，特别是在实现 shell、守护进程或其他需要启动新程序的应用程序时。
  • 它也可以用于替换当前进程的映像，因此在创建子进程后（通常使用 fork），可以调用 execve 来在子进程中运行新的程序。

总结

  • execve 是一个强大的系统调用，用于执行指定的程序并替换当前进程的映像。
  • 它提供了一个低级接口来运行外部命令，通常与 fork 一起使用以创建新进程。
  • 理解 execve 的工作机制是 Unix/Linux 编程中的一项重要技能，尤其是在涉及进程管理时。

access

access 是一个标准的 POSIX 系统调用，用于检查调用进程是否有权限访问指定的文件或目录。它允许检查特定的权限，例如文件的可读、可写或可执行权限。它通常用于在打开文件或执行文件操作之前，验证进程是否有足够的权限来执行相应的操作。

函数原型

int access(const char *pathname, int mode);
  • pathname：这是要检查的文件或目录的路径。
  • mode：一个整数值，表示要检查的权限类型。

mode 参数的常量值

  • F_OK：检查文件是否存在。
  • R_OK：检查文件是否可读。
  • W_OK：检查文件是否可写。
  • X_OK：检查文件是否可执行。

这些常量可以组合使用来检查多个权限。例如，R_OK | W_OK 检查文件是否同时具有可读和可写权限。

返回值

  • 成功：如果调用进程有相应的权限，则 access 返回 0。
  • 失败：如果进程没有相应的权限，或者文件/目录不存在，access 返回 -1，并设置 errno 来描述错误原因。

使用场景

access 函数常用于程序需要在执行某些文件操作（例如打开文件、写入文件、执行文件）之前，确保调用进程有足够的权限。例如，程序可以通过 access 确认文件存在，并且进程有权限读取或写入该文件。

示例代码
#include <stdio.h>
#include <unistd.h>int main() {const char *filename = "testfile.txt";if (access(filename, F_OK) != -1) {printf("File exists\n");if (access(filename, R_OK) != -1) {printf("File is readable\n");} else {printf("File is not readable\n");}if (access(filename, W_OK) != -1) {printf("File is writable\n");} else {printf("File is not writable\n");}} else {printf("File does not exist\n");}return 0;
}

在这个例子中，程序首先检查文件是否存在，然后检查文件是否具有读写权限。根据检查的结果，程序会输出相应的信息。

安全性考虑

  1. TOCTOU（时间-检查-使用漏洞）：使用 access 函数时需要小心，因为它可能引发“时间-检查-使用”漏洞（TOCTOU）。这类漏洞出现在调用 access 检查权限后，文件的状态可能在接下来的操作（如 open、read）中发生变化。如果恶意用户能在权限检查和后续操作之间修改文件状态，可能导致安全问题。

  2. 权限与实际用户 ID：access 检查调用进程的实际用户 ID 和组 ID 而非有效用户 ID，因此它适用于一些特定的场景，例如 setuid 程序在以非特权用户运行时检查权限。

总结

access 函数是用来检查当前进程是否有权限访问指定文件或目录的工具。它可以用于检测文件是否存在以及是否具有读写执行权限。不过，必须注意避免使用过程中可能带来的安全漏洞，例如 TOCTOU 问题。

va_start

va_start 是一个宏，用于初始化一个 va_list 类型的变量，以便访问可变参数列表。在 C 和 C++ 中，当一个函数接受可变数量的参数时（如 printf 函数），需要使用 va_start、va_arg 和 va_end 等宏来处理这些参数。这些宏定义在 stdarg.h 头文件中。

以下是一个关于 va_start 的详细解释及其用法：

va_start、va_arg 和 va_end

语法：

void va_start(va_list ap, last);

参数：

  • ap：这是 va_list 类型的变量，用于存储可变参数信息。
  • last：这是函数参数列表中最后一个确定的参数，即在省略号 ... 之前的那个参数。

用法示例

下面是一个使用 va_start、va_arg 和 va_end 的示例，演示如何实现一个简单的变参函数：

#include <stdio.h>
#include <stdarg.h>// 一个简单的变参函数，计算所有整数参数的和
int sum(int count, ...) {va_list args;int total = 0;// 初始化 va_list 变量va_start(args, count);// 访问每个参数for (int i = 0; i < count; i++) {total += va_arg(args, int);}// 清理 va_list 变量va_end(args);return total;
}int main() {printf("Sum of 1, 2, 3 is %d\n", sum(3, 1, 2, 3));printf("Sum of 4, 5, 6, 7, 8 is %d\n", sum(5, 4, 5, 6, 7, 8));return 0;
}

strtok

strtok 是 C 标准库中的一个函数，用于将字符串分割成一系列标记（tokens）。这是一个非常有用的函数，尤其是在处理文本数据时，它可以帮助你从字符串中提取单独的单词或其他子字符串。

函数原型

char *strtok(char *str, const char *delim);

参数说明

  1. str:

    • 这是要被分割的字符串。在第一次调用 strtok 时，传入要解析的字符串。后续调用时，传入 NULL 以继续解析同一字符串。

  2. delim:

    • 这是一个包含分隔符的字符串。strtok 将根据这个字符集来分割 str 字符串。常见的分隔符包括空格、逗号、句号等。

返回值

  • strtok 返回指向下一个标记的指针（以 null 结尾的字符串）。如果没有更多的标记可供返回，则返回 NULL。

使用注意事项

  • strtok 会修改原始字符串，它会用 '\0' 替换分隔符，以便将分隔的部分转换为独立的字符串。
  • strtok 不是线程安全的。如果在多个线程中使用同一字符串，可能会导致未定义行为。对于线程安全的替代方法，可以使用 strtok_r。

示例代码

以下是一个使用 strtok 的示例：

#include <stdio.h>
#include <string.h>int main() {char str[] = "Hello, world! This is a test.";const char *delim = " ,.!"; // 分隔符包括空格、逗号、点和感叹号char *token;// 获取第一个标记token = strtok(str, delim);// 继续获取其他标记while (token != NULL) {printf("%s\n", token); // 打印每个标记token = strtok(NULL, delim); // 继续分割}return 0;
}

输出

运行以上程序时，输出将是：

Hello
world
This
is
a
test

总结

  • strtok 是一个简单而强大的工具，用于字符串的分割。
  • 它通过替换分隔符为 '\0' 来修改原始字符串，并返回每个标记的指针。
  • 使用时需注意原始字符串会被修改，并且在多线程环境中要小心使用。

fgets

fgets 是 C 标准库中的一个函数，用于从指定的文件流中读取一行字符串。它的主要用途是从文件或标准输入（例如键盘）读取文本数据，直到遇到换行符、文件结束符或达到指定的字符数限制。

函数原型

char *fgets(char *str, int n, FILE *stream);

参数说明

  1. char *str:

    • 用于存储读取到的字符串的缓冲区（数组）。这个缓冲区必须足够大，以容纳要读取的字符串及其终止的空字符 '\0'。

  2. int n:

    • 指定要读取的最大字符数（包括终止的空字符）。即在读取时，fgets 会最多读取 n - 1 个字符，留出一个位置给 '\0'。

  3. FILE *stream:

    • 指向要读取的文件流的指针。可以是使用 fopen 打开的文件，或者是标准输入流 stdin。

返回值

  • 如果成功，fgets 返回指向 str 的指针。
  • 如果发生错误或到达文件末尾（EOF），返回 NULL。如果读取到了换行符，fgets 会将换行符也包含在字符串中。

特点

  • fgets 会在读取到换行符时停止，并将换行符也包括在返回的字符串中。
  • 它会自动在读取的字符串的末尾添加空字符 '\0'，以标识字符串的结束。
  • 不会导致缓冲区溢出，因为它会限制读取的字符数。

示例代码

下面是一个使用 fgets 的简单示例：

#include <stdio.h>int main() {char buffer[100]; // 创建一个缓冲区printf("请输入一行文本：");if (fgets(buffer, sizeof(buffer), stdin) != NULL) {printf("你输入的文本是：%s", buffer);} else {printf("读取输入失败。\n");}return 0;
}

输出示例

假设用户输入了 “Hello, World!”，程序将输出：

请输入一行文本：Hello, World!
你输入的文本是：Hello, World!

注意事项

  1. 换行符的处理：

    • fgets 会将换行符包括在读取的字符串中，如果希望去掉换行符，可以在读取后手动处理：
    buffer[strcspn(buffer, "\n")] = '\0'; // 删除换行符

  2. 缓冲区大小：

    • 确保缓冲区足够大，以避免溢出。使用 sizeof(buffer) 可以动态获取缓冲区大小。

  3. 错误处理：

    • 在实际使用中，检查返回值以确保读取成功，以及处理可能的错误是非常重要的。

总结

fgets 是一个非常实用的函数，用于安全地从文件流中读取字符串。了解其用法和特性对于处理文本输入非常重要。如果你还有其他问题或需要进一步的信息，请告诉我！

prctl

prctl 是一个在 Linux 系统上用于控制进程行为的系统调用。它可以用来设置或获取进程的属性。这个函数非常灵活，提供了多种操作，可以通过不同的命令来管理进程的特性，例如设置资源限制、调度策略、进程优先级等。

函数原型

在 C 语言中，prctl 的函数原型如下：

int prctl(int option, ...);

参数说明

  • option: 指定要执行的操作的类型。这个参数可以是多个预定义的常量，例如：

    • PR_SET_NAME: 设置进程的名称。
    • PR_GET_NAME: 获取进程的名称。
    • PR_SET_PDEATHSIG: 设置父进程死亡时发送给当前进程的信号。
    • PR_SET_NO_NEW_PRIVS: 设置进程不能获得新特权。
    • PR_GET_NO_NEW_PRIVS: 获取当前进程是否可以获得新特权。
    • 还有其他许多选项。

  • …: 依赖于选项的额外参数。例如，当使用 PR_SET_NAME 时，你需要提供一个字符串指针来设置进程名称。

返回值

  • 如果成功，返回 0。
  • 如果失败，返回 -1，并设置 errno 以指示错误类型。

示例

下面是一个使用 prctl 设置进程名称的简单示例：

#include <stdio.h>
#include <string.h>
#include <sys/prctl.h>
#include <unistd.h>int main() {// 设置进程名称const char *new_name = "my_process";if (prctl(PR_SET_NAME, new_name) != 0) {perror("prctl");return 1;}// 获取进程名称char name[16];prctl(PR_GET_NAME, name);printf("Process name is: %s\n", name);// 让进程持续运行，方便查看while (1) {sleep(1);}return 0;
}

在这个示例中：

  1. 使用 prctl 设置进程名称为 “my_process”。
  2. 使用 prctl 获取当前进程的名称并打印出来。
  3. 进程将持续运行，以便我们可以在操作系统中查看其名称。

常见用途

  • 改进安全性: 使用 PR_SET_NO_NEW_PRIVS 来防止进程获得新的特权。
  • 设置资源限制: 通过 PR_SET_RESOURCE 等选项来限制进程使用的资源。
  • 信号处理: 设置进程在其父进程死亡时接收特定信号。

总结

prctl 是一个强大的工具，允许开发者控制和管理进程的行为，适用于需要进行低级进程管理的复杂应用程序。在使用时，务必查阅相关文档，了解每个选项的详细信息和潜在影响。

_stdio_common_vfprintf

_stdio_common_vfprintf 是一个在 C/C++ 标准库中（尤其是 Microsoft 的实现中）使用的内部函数，它通常与格式化输出有关。以下是对这个函数的详细解释：

函数概述

  • 功能：_stdio_common_vfprintf 是一个变体的 fprintf 函数，主要用于将格式化的数据输出到指定的文件流。它的名称表明它是一个“公共”版本，可能用于内部实现，以便于处理不同的输出场景。

  • 参数：

    • 通常，它会接受一个文件指针（如 FILE *），一个格式字符串（const char *），以及一个 va_list 类型的参数，用于处理可变参数列表。

使用场景

  • 变参函数：_stdio_common_vfprintf 常常是作为其他变参函数（如 fprintf 或 printf）的底层实现。它允许函数在不直接处理可变参数的情况下传递参数，从而简化处理流程。

  • 格式化输出：与 fprintf 类似，这个函数的主要任务是根据给定的格式字符串将数据输出到指定的流中。它处理格式化字符串中的各种格式化标志、宽度、精度等信息。

示例

虽然 _stdio_common_vfprintf 通常不是直接调用的函数，但可以通过 fprintf 等函数间接使用。以下是一个简单的示例，展示了如何使用 fprintf，而底层可能会调用 _stdio_common_vfprintf：

#include <stdio.h>int main() {FILE *fp = fopen("output.txt", "w");if (fp == NULL) {perror("Failed to open file");return 1;}int value = 42;fprintf(fp, "The answer is: %d\n", value);  // 这可能会调用 _stdio_common_vfprintffclose(fp);return 0;
}

实现细节

  • 内部实现：由于 _stdio_common_vfprintf 是一个内部函数，它的具体实现细节可能会在不同的编译器或标准库实现中有所不同。在 Microsoft 的实现中，它可能会处理各种错误检查、缓冲管理和格式解析等任务。

  • 效率：通过将公共的格式化逻辑集中在一个函数中，库的设计者可以提高代码的重用性和维护性。

总结

_stdio_common_vfprintf 是一个用于处理格式化输出的内部函数，通常不是用户直接调用的。它为标准输出函数提供底层实现，处理可变参数并执行格式化任务。对于大多数开发者而言，直接使用 fprintf、printf 或 snprintf 等函数就足够了，而不需要了解其具体的内部实现。

_stdio_common_vfscanf

_stdio_common_vfscanf 是 C 语言标准库中一个内部函数，尤其是在 Microsoft C 运行库中。它与格式化输入相关，通常用于处理从文件或标准输入流中读取数据。以下是对 _stdio_common_vfscanf 的详细解释：

函数概述

  • 功能：_stdio_common_vfscanf 是一个变体的 vfscanf 函数，主要用于读取格式化的数据，通常是从指定的文件流中。它的名称表示这是一个“公共”实现，可能是为了内部使用，方便处理不同的输入场景。

  • 参数：

    • 通常，它会接受一个文件指针（FILE *），一个格式字符串（const char *），以及一个 va_list 类型的参数，用于处理可变参数列表。这使得它能够在不直接处理可变参数的情况下传递参数。

使用场景

  • 变参函数：_stdio_common_vfscanf 常常是作为其他变参函数（如 fscanf 或 scanf）的底层实现。它允许函数在不直接处理可变参数的情况下进行输入处理，从而简化处理流程。

  • 格式化输入：与 fscanf 类似，这个函数的主要任务是根据给定的格式字符串从输入流中读取并解析数据。它处理格式化字符串中的各种格式标志、宽度、精度等信息，确保从输入流中准确地读取所需的数据。

示例

虽然 _stdio_common_vfscanf 通常不是直接调用的函数，但可以通过 fscanf 等函数间接使用。以下是一个简单的示例，展示了如何使用 fscanf，而底层可能会调用 _stdio_common_vfscanf：

#include <stdio.h>int main() {FILE *fp = fopen("input.txt", "r");if (fp == NULL) {perror("Failed to open file");return 1;}int value;// 这可能会调用 _stdio_common_vfscanfif (fscanf(fp, "%d", &value) == 1) {printf("Read value: %d\n", value);} else {printf("Failed to read an integer.\n");}fclose(fp);return 0;
}

实现细节

  • 内部实现：作为一个内部函数，_stdio_common_vfscanf 的具体实现细节可能因不同的编译器或标准库实现而异。在 Microsoft 的实现中，它可能会处理各种错误检查、缓冲管理和格式解析等任务。

  • 效率：通过将公共的输入逻辑集中在一个函数中，库的设计者能够提高代码的重用性和维护性。

功能总结

  • 数据读取：_stdio_common_vfscanf 负责从指定的输入流中根据格式字符串读取数据并将其存储到相应的变量中。

  • 错误处理：它通常会进行一些基本的错误处理，例如检查读取的数据是否符合预期的格式。

  • 输入解析：解析并处理格式字符串中的各种格式说明符，例如 %d（整数）、%f（浮点数）、%s（字符串）等。

总结

_stdio_common_vfscanf 是一个用于处理格式化输入的内部函数，通常不是用户直接调用的。它为标准输入函数提供底层实现，处理可变参数并执行格式化输入任务。对于大多数开发者而言，直接使用 fscanf、scanf 或 sscanf 等函数就足够了，而不需要了解其具体的内部实现。

mprotect

mprotect 是一个在 Unix/Linux 系统中用于修改内存页保护属性的系统调用。它允许程序员更改特定内存区域的访问权限，例如设置某个内存区域为可读、可写或可执行。这个功能在实现内存保护和安全性方面非常重要。

1. 函数原型

在 C 语言中，mprotect 的函数原型定义如下：

int mprotect(void *addr, size_t len, int prot);

2. 参数说明

  • addr: 指向要更改保护属性的内存区域的起始地址。这个地址应该是页面对齐的（通常是系统页面大小的倍数）。
  • len: 要修改保护属性的字节数。这个值应该也是页面对齐的。
  • prot: 新的保护标志，指定内存区域的访问权限。常用的标志包括：
    • PROT_READ: 允许读取。
    • PROT_WRITE: 允许写入。
    • PROT_EXEC: 允许执行。
    • PROT_NONE: 不允许访问。

可以通过按位或运算组合这些标志，例如 PROT_READ | PROT_WRITE。

3. 返回值

  • 成功时返回 0。
  • 失败时返回 -1，并设置 errno 变量以指示错误原因。常见的错误包括：
    • EACCES: 试图设置不允许的保护标志。
    • EINVAL: 提供的地址不是有效的内存地址，或者长度无效。
    • ENOMEM: 请求的内存区域不在进程的虚拟地址空间内。

4. 使用示例

以下是一个使用 mprotect 的简单示例，演示如何将一个内存区域设置为可读和可写：

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <sys/mman.h>
#include <unistd.h>int main() {// 分配一块内存size_t page_size = sysconf(_SC_PAGESIZE);void *ptr = malloc(page_size);if (ptr == NULL) {perror("malloc");return EXIT_FAILURE;}// 将内存区域设置为可读和可写if (mprotect(ptr, page_size, PROT_READ | PROT_WRITE) == -1) {perror("mprotect");free(ptr);return EXIT_FAILURE;}// 在内存中写入数据strcpy(ptr, "Hello, World!");printf("%s\n", (char *)ptr);// 释放内存free(ptr);return EXIT_SUCCESS;
}

5. 注意事项

  • 页面对齐: mprotect 要求提供的地址和长度必须是页面对齐的，通常这意味着它们应该是系统页面大小的倍数。可以使用 sysconf(_SC_PAGESIZE) 获取系统的页面大小。
  • 安全性: 使用 mprotect 可以改变内存的访问权限，这在动态生成代码或内存保护技术中非常有用，但也可能导致安全隐患，需谨慎使用。
  • 可执行内存: 在现代系统中，出于安全目的，某些内存区域可能默认不允许执行。使用 mprotect 时，应确保正确使用 PROT_EXEC 标志，并考虑系统的安全策略。

6. 实际应用

mprotect 常用于以下场景：

  • 动态代码生成: 允许程序在运行时生成的代码段可执行。
  • 内存保护: 动态改变内存区域的访问权限，以防止非法访问。
  • 实现 JIT 编译器: 在 Just-In-Time 编译中，动态生成代码并执行。

pthread_create

pthread_create 是 POSIX 线程库（pthread）中的一个函数，用于创建新线程。它是多线程编程的核心功能之一，允许程序在运行时并发执行多个线程。下面是对 pthread_create 的详细解释，包括其参数、用法和示例。

函数原型

#include <pthread.h>int pthread_create(pthread_t *thread, const pthread_attr_t *attr, void *(*start_routine)(void *), void *arg);

参数说明

  • pthread_t *thread: 这是一个指向 pthread_t 类型的指针，用于返回新创建线程的标识符。你可以用这个标识符来管理线程（如等待线程结束、取消线程等）。

  • const pthread_attr_t *attr: 这是一个指向线程属性对象的指针，可以用来设置线程的属性。如果你不需要自定义属性，可以传递 NULL，这将使用默认属性。

  • void *(*start_routine)(void *): 这是一个指向将要执行的函数的指针。该函数的返回类型为 void *，并接受一个 void * 类型的参数。这个函数就是线程开始执行时会调用的函数。

  • void *arg: 这是传递给 start_routine 的参数。由于函数参数被定义为 void *，所以可以传递任何类型的数据（需要在函数中进行类型转换）。

返回值

  • 如果成功，pthread_create 返回 0。
  • 如果失败，返回一个错误码，表示错误的类型。例如，如果系统无法分配足够的资源，可能返回 EAGAIN。

示例代码

下面是一个简单的示例，演示如何使用 pthread_create 创建一个线程：

#include <stdio.h>
#include <stdlib.h>
#include <pthread.h>// 线程执行的函数
void *thread_function(void *arg) {int *num = (int *)arg;  // 将 void * 转换为 int *printf("Thread: received number %d\n", *num);return NULL;
}int main() {pthread_t thread;        // 创建线程的变量int number = 42;        // 要传递给线程的参数// 创建线程if (pthread_create(&thread, NULL, thread_function, &number) != 0) {perror("Failed to create thread");return 1;}// 等待线程结束if (pthread_join(thread, NULL) != 0) {perror("Failed to join thread");return 1;}printf("Main: thread has finished execution.\n");return 0;
}

示例解析

  1. thread_function: 这是线程将执行的函数，它接受一个 void * 类型的参数，并将其转换为 int *，然后打印接收到的数字。

  2. pthread_create: 在 main 函数中，调用 pthread_create 创建一个新线程。传入的参数包括线程标识符、属性（这里使用默认属性）、线程执行的函数和参数。

  3. pthread_join: 主线程调用 pthread_join，等待新创建的线程执行完毕。这可以防止主线程在子线程完成之前退出，从而避免资源泄漏。

注意事项

  • 线程安全: 在多线程环境中，确保共享资源的访问是线程安全的（如使用互斥锁）。

  • 资源管理: 使用 pthread_join 等待线程结束是一个好的实践，以确保线程资源被正确释放。

  • 错误处理: 始终检查 pthread_create 和 pthread_join 的返回值，以处理可能出现的错误。

总结

pthread_create 是创建和管理线程的基础函数，理解其用法对于进行并发编程至关重要。通过使用该函数，可以在程序中实现多线程以提高性能和响应能力。

strchr

strchr 是 C 标准库中的一个字符串处理函数，用于查找字符串中第一次出现特定字符的位置。它属于 <string.h> 头文件，并且常用于字符串操作。

函数原型

#include <string.h>char *strchr(const char *s, int c);

参数说明

  • const char *s: 指向要搜索的 C 字符串（以空字符 \0 结尾的字符数组）。

  • int c: 要搜索的字符，可以是一个字符的 ASCII 值。例如，如果要搜索字符 'a'，则可以传递 int c = 'a';。

返回值

  • 如果找到字符 c，strchr 返回指向该字符在字符串 s 中第一次出现位置的指针。
  • 如果没有找到字符，返回 NULL。

使用示例

下面是一个使用 strchr 的简单示例：

#include <stdio.h>
#include <string.h>int main() {const char *str = "Hello, World!";char ch = 'o';// 查找字符 'o' 在字符串中的位置char *result = strchr(str, ch);if (result) {printf("Character '%c' found at position: %ld\n", ch, result - str);} else {printf("Character '%c' not found in the string.\n", ch);}return 0;
}

示例解析

  1. 字符串定义: const char *str = "Hello, World!"; 定义了一个字符串。

  2. 查找字符: char *result = strchr(str, ch); 使用 strchr 查找字符 o 在字符串中的位置。

  3. 检查结果:

    • 如果 result 不为 NULL，则表示找到了该字符。通过 result - str 计算出它在字符串中的索引位置。
    • 如果 result 为 NULL，则表示没有找到该字符。

注意事项

  • 字符比较: 传递给 strchr 的字符参数是一个 int 类型的值，通常是字符的 ASCII 值。确保在调用时传递正确的字符。

  • 返回值处理: 始终检查 strchr 的返回值，以避免在空指针上进行解引用。

  • 空字符: strchr 也会返回指向字符串终止符 \0 的指针，如果字符 c 是 \0，说明它在字符串的末尾。

总结

strchr 是一个非常有用的函数，适用于查找字符串中的特定字符。它可以帮助处理字符串数据，查找字符位置，并且在许多字符串操作中都很常见。


http://www.mrgr.cn/news/58342.html

相关文章：

  • Atcoder ABC365 A-D 题解（天津青年宫青少年计算思维算法周赛活动(三十一) 题解）
  • 简单记录ios打包流程
  • 激光雷达定位与建图-最近邻问题
  • 晨辉考试抽签软件的两种注册方法之二：在线注册
  • sql-labs靶场第二十一关测试报告
  • c#实现PDF文件的合并
  • 一年四起供应链投毒事件的幕后黑手
  • 储能蓝海：技术革新与成本骤降引爆市场
  • python_删除二维列表的制定列
  • 商汤科技裁员动真格，战略转型组织大变革
  • 基于STM32设计的智能鱼缸(蓝牙版)
  • Vue Router 如何配置 404 页面？
  • GFF: Gated Fully Fusion for Semantic Segmentation门控融合语义分割-论文阅读笔记
  • 华为OD机试 - 字符串最后一个单词的长度（Java 2024 E卷 100分）
  • web 应用层接口请求日志
  • 面试题：JVM（一）
  • DLL修复工具 v4.2.0.40217 免安装一键修复
  • linux下gpio模拟spi三线时序
  • opencv - py_imgproc - py_geometric_transformations 几何变换
  • 设计师的新宠：7款不容错过的界面设计软件
  • Telegram机器人的手机部署
  • 股市动向背后有哪些因素？我们该如何应对？
  • 网络服务请求流程简单理解
  • uniapp renderjs页面传值
  • springboot大学校园报修管理平台-计算机毕业设计源码90736
  • 华为开放式耳机测评，南卡 、华为、Cleer开放式耳机超深度横评