linux——IPC 进程间通信

最新推荐文章于 2024-07-12 16:39:24 发布
最新推荐文章于 2024-07-12 16:39:24 发布
阅读量904 收藏 28
点赞数 14
文章标签： linux 运维 服务器
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_71703182/article/details/140118244
版权

 IPC   进程间通信  interprocess communicate

IPC（Inter-Process Communication），即进程间通信，其产生的原因主要可以归纳为以下几点：

进程空间的独立性

  1. 资源隔离：在现代操作系统中，每个进程都拥有自己独立的代码和数据空间。这种隔离机制确保了进程之间的安全性和稳定性，但同时也使得进程间无法直接访问对方的资源。

  2. 资源无法共享：由于进程空间的独立性，一个进程无法直接读取或修改另一个进程的内存空间中的数据。这种情况下，如果需要进行数据交换或共享资源，就需要通过特定的机制来实现。

进程间协作的需求

  1. 数据交换：在多进程操作系统中，不同的进程可能需要交换数据以完成共同的任务。例如，一个进程可能负责生成数据，而另一个进程则负责处理这些数据。为了实现这种数据交换，就需要使用IPC机制。

  2. 资源共享：进程间通信还允许进程共享资源，如文件、数据库、内存等。通过IPC，进程可以协调对共享资源的访问，避免冲突和竞争条件。

  3. 任务协调：在分布式系统或并发编程中，多个进程可能需要协同工作以完成复杂的任务。IPC提供了进程间同步和互斥的机制，确保任务能够按照预定的顺序和条件执行。

IPC的必要性

  1. 提高系统并发性：通过IPC，多个进程可以并行处理不同的任务，从而提高系统的并发处理能力。

  2. 优化资源利用：IPC允许进程共享资源，减少了资源的重复分配和浪费，提高了资源利用率。

  3. 实现复杂功能：在构建复杂的软件系统时，往往需要多个进程协同工作。IPC为这些进程之间的通信和协作提供了必要的支持。

IPC的实现方式

IPC的实现方式多种多样，包括但不限于以下几种：

  1. 管道（Pipe）：一种单向通信方式，常用于具有亲缘关系的进程间通信。

  2. 消息队列（Message Queue）：允许多个进程从同一个队列中读取数据，具有独立性和异步性。

  3. 共享内存（Shared Memory）：一段可以被多个进程同时访问的物理内存区域，提高了进程间的数据交换效率。

  4. 信号（Signal）：一个进程向另一个进程发送信号来传递某种信息或通知某个事件的发生。

  5. 套接字（Socket）：用于不同主机之间的进程通信，提供了网络通信的能

管道==》无名管道、有名管道

    无名管道 ===》pipe ==》只能给有亲缘关系进程通信
    有名管道 ===》fifo ==》可以给任意单机进程通信


    管道的特性：
    1、管道是 半双工的工作模式（收或者发）
    2、所有的管道都是特殊的文件不支持定位操作。不支持lseek->> fd  fseek ->>FILE* 
    3、管道是特殊文件，读写使用文件IO。fgets,fread,fgetc,

       一般情况下使用open,read,write,close;

主要看是否是二进制文件，如果是文本文件使用fges之类的标准io。

注意事项：  
   1,读端存在，一直向管道中去写，超过64k，写会阻塞。（写的快，读的慢）

#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <string.h>
int main(int argc, char *argv[])
{
    
    int pipefd[2]={0};
    int ret = pipe(pipefd);
    if(-1 == ret)
    {
        perror("pipe");
        exit(1);
    }


    pid_t pid = fork();
    if(pid>0)
    {
        char buf[]="hello,world";
        close(pipefd[0]);
        sleep(3);
        write(pipefd[1],buf,strlen(buf));
    }
    else if(0 == pid)
    {
        close(pipefd[1]);
        char buf[100]={0};
        read(pipefd[0],buf,sizeof(buf));
        printf("pipe %s\n",buf);
    }
    else 
    {
        perror("fork");
        exit(1);
    }
    return 0;
}

   2，写端是存在的，读管道，如果管道为空的话，读会阻塞（读的快，写的慢）

    读阻塞和写阻塞都是正常情况。

#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <string.h>
int main(int argc, char *argv[])
{
    
    int pipefd[2]={0};
    int ret = pipe(pipefd);
    if(-1 == ret)
    {
        perror("pipe");
        exit(1);
    }


    pid_t pid = fork();
    if(pid>0)
    {
        char buf[1024]={0};
        close(pipefd[0]);
        memset(buf,'a',1024);
        int i = 0 ;
        for(i=0;i<65;i++)
        {
            write(pipefd[1],buf,sizeof(buf));
            printf("i is %d\n",i);
        }
    }
    else if(0 == pid)
    {
        close(pipefd[1]);
        char buf[100]={0};
//        read(pipefd[0],buf,sizeof(buf));
  //      printf("pipe %s\n",buf);
        while(1)sleep(1);
    }
    else 
    {
        perror("fork");
        exit(1);
    }
    return 0;
}

  3.管道破裂，读端关闭，写管道。

（会导致写关闭，接收端关闭，导致发送端关闭）类似于段错误

#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <string.h>
int main(int argc, char *argv[])
{
    
    int pipefd[2]={0};
    int ret = pipe(pipefd);
    if(-1 == ret)
    {
        perror("pipe");
        exit(1);
    }


    pid_t pid = fork();
    if(pid>0)
    {
        char buf[]="hello,world";
        close(pipefd[0]);
        sleep(3);
        // 管道破裂 gdb  跟踪
        write(pipefd[1],buf,strlen(buf));
        printf("aaaa\n");
    }
    else if(0 == pid)
    {
        close(pipefd[1]);
        close(pipefd[0]);
    }
    else 
    {
        perror("fork");
        exit(1);
    }
    return 0;
}


   4. read 0 ,写端关闭，如果管道没有内容，read 0 ；

#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <string.h>
int main(int argc, char *argv[])
{
    
    int pipefd[2]={0};
    int ret = pipe(pipefd);
    if(-1 == ret)
    {
        perror("pipe");
        exit(1);
    }


    pid_t pid = fork();
    if(pid>0)
    {
        char buf[]="hello,world";
        close(pipefd[0]);
        write(pipefd[1],buf,strlen(buf));
        write(pipefd[1],buf,strlen(buf));
        close(pipefd[1]);
    }
    else if(0 == pid)
    {
        close(pipefd[1]);
            char buf[5]={0};
        while(1)
        {
            //memset(buf,0,5);
            bzero(buf,sizeof(buf));
            int rd_ret = read(pipefd[0],buf,sizeof(buf)-1);
            if(rd_ret<=0)
            {
                break;
            }
            printf("pipe %s\n",buf);
        }
    }
    else 
    {
        perror("fork");
        exit(1);
    }
    return 0;
}

 if(rd_ret<=0)
            {
                break;
            }

如果读端进程调用read()函数从管道中读取数据，并且管道已经为空（即没有任何待读取的数据），同时写端已经被关闭，那么read()函数将会立即返回，并且返回值为0。这个返回值0是一个特殊的信号，它告诉读端进程，管道的写端已经被关闭，并且管道中没有更多的数据可以读取了。

使用框架：
    创建管道 ==》读写管道 ==》关闭管道

1、无名管道 ===》管道的特例 ===>pipe函数
    特性：
    1.1  亲缘关系进程使用
    1.2  有固定的读写端

   

流程：
    创建并打开管道： pipe函数

先创建管道再fork（）；

关闭管道1或者0用，close（xx）；
#include <unistd.h>
int pipe(int pipefd[2]);
功能：创建并打开一个无名管道
参数：pipefd[0] ==>无名管道的固定读端
      pipefd[1] ==>无名管道的固定写端
返回值：成功 0
        失败 -1；

注意事项：
    1、无名管道的架设应该在fork之前进行。
    
无名管道的读写：===》文件IO的读写方式。
    读： read()
    写： write()

关闭管道： close();

通过管道的方式实现文件的复制：

#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <string.h>
#include <fcntl.h>
int main(int argc, char *argv[])
{
    
    int pipefd[2]={0};
    int ret = pipe(pipefd);
    if(-1 == ret)
    {
        perror("pipe");
        exit(1);
    }


    pid_t pid = fork();
    if(pid>0)
    {
        close(pipefd[0]);
       int fd =  open("/home/linux/1.png",O_RDONLY);
       if(-1 == fd)
       {
            perror("open");
            exit(1);
       }
       while(1)
       {
            char buf[4096]={0};
            int rd_ret = read(fd,buf,sizeof(buf));
            if(rd_ret<=0)
            {
                break;
            }
            write(pipefd[1],buf,rd_ret);
       
       }
       close(fd);
       close(pipefd[1]);
    }
    else if(0 == pid)
    {
        close(pipefd[1]);
        int fd = open("2.png",O_WRONLY|O_CREAT|O_TRUNC,0666);
        if(-1==fd)
        {
            perror("open");
            exit(1);
        }
        while(1)
        {
            char buf[1024]={0};
            int rd_ret = read(pipefd[0],buf,sizeof(buf));
            if(rd_ret<=0)
            {
                break;
            }
            write(fd,buf,rd_ret);
        }
        close(fd);
        close(pipefd[0]);
    }
    else 
    {
        perror("fork");
        exit(1);
    }
    return 0;
}


验证如下问题：
1、父子进程是否都有fd[0] fd[1],
   如果在单一进程中写fd[1]能否直接从fd[0]中读到。

   可以，写fd[1]可以从fd[0]读

2、管道的数据存储方式是什么样的
   数据是否一直保留？
    栈， 先进后出
   队列形式存储 读数据会剪切取走数据不会保留
   先进先出

3、管道的数据容量是多少，有没有上限值。
    操作系统的建议值： 512* 8 = 4k
    代码测试实际值：   65536byte= 64k

4、管道的同步效果如何验证？读写同步验证。
    读端关闭能不能写？ 不可以 ===>SIGPIPE 异常终止 （触发管道破裂）
    写端关闭能不能读？ 可以，取决于pipe有没有内容，===>read返回值为0 不阻塞

    结论：读写端必须同时存在，才能进行
          管道的读写。


5、固定的读写端是否就不能互换？
    能否写fd[0] 能否读fd[1]?   不可以，是固定读写端。

    
练习：
    如何用管道实现一个双向通信功能
    将从父进程发送的消息在发回给父
    进程。
    
    
    pipe,
    
    fork()
    
    if(pid>0)
    {
        read(file,,)
        wirte(fd[1]);
    }
    
    if(0 == pid)
    {
            read(fd[0]);
            write(newfile);
    }
    
    
    
    person
    {
        char name[];
        int age;
        char phone;
    }
    
    
    pipe[];
    fork();
    
    > 0
    fgets 获得输入
    填结构体，
    写入管道，
    ==0
    
    read，
    填结构体，，
    
    显示到。。。
    
    hello
    pipe:hello 
    wordld
    pipe2 ::world;
    
    
    
    
    
    

有名管道===》fifo ==》有文件名称的管道。
                      文件系统中可见

框架：
    创建有名管道 ==》打开有名管道 ==》读写管道
    ==》关闭管道  ==》卸载有名管道

1、创建：mkfifo
#include <sys/types.h>
#include <sys/stat.h>
 remove();

int mkfifo(const char *pathname, mode_t mode);
功能：在指定的pathname路径+名称下创建一个权限为
      mode的有名管道文件。
参数：pathname要创建的有名管道路径+名称
      mode  8进制文件权限。
返回值：成功 0
        失败  -1；

2、打开有名管道 open
    注意：该函数使用的时候要注意打开方式，
    因为管道是半双工模式，所有打开方式直接决定
    当前进程的读写方式。
    一般只有如下方式：
    int fd-read = open("./fifo",O_RDONLY); ==>fd 是固定读端
    int fd-write = open("./fifo",O_WRONLY); ==>fd 是固定写端
    不能是 O_RDWR 方式打开文件。
    不能有 O_CREAT 选项，因为创建管道有指定的mkfifo函数


3、管道的读写： 文件IO

    读： read(fd-read,buff,sizeof(buff));
    写： write(fd-write,buff,sizeof(buff));

4、关闭管道：
        close(fd)；

5、卸载管道：remove();
        int unlink(const char *pathname);
        功能：将指定的pathname管道文件卸载，同时
              从文件系统中删除。
        参数： ptahtname 要卸载的有名管道 
        返回值：成功 0
                失败  -1；

open会阻塞，等到另一端读端打开，解除阻塞。

函数是否会阻塞，具体根据操作的对象有关。


#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <string.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <fcntl.h>
#include <errno.h>
int main(int argc, char *argv[])
{
    int ret = mkfifo("myfifo",0666);    
    if(-1 == ret)
    {
        //如果是管道文件已存在错误，让程序继续运行
        if(EEXIST== errno)
        {

        }else 
        {
            perror("mkfifo");
            exit(1);
        }
    }
    //open 会阻塞，等到另一端读段打开，解除阻塞
    int fd = open("myfifo",O_WRONLY);
    if(-1 == fd)
    {
        perror("open");
        exit(1);
    }

    char buf[256]="hello,fifo,test";
    write(fd,buf,strlen(buf));
    close(fd);

    return 0;
}

#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <string.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <fcntl.h>
#include <errno.h>

int main(int argc, char *argv[])
{
    int ret = mkfifo("myfifo",0666);    
    if(-1 == ret)
    {
        //如果是管道文件已存在错误，让程序继续运行
        if(EEXIST== errno)
        {
        
        }else 
        {
            perror("mkfifo");
            exit(1);
        }
    }

    int fd = open("myfifo",O_RDONLY);
    if(-1 == fd)
    {
        perror("open");
        exit(1);
    }

    char buf[256]={0};
    read(fd,buf,sizeof(buf));
    printf("fifo %s\n",buf);
    close(fd);
    //remove("myfifo");

    return 0;
}

remove可以在命令行调用。

运行方法：

练习：
    编写一个非亲缘关系进程间通信程序，可以从
    A程序向B程序连续发送不同的数据，并从B中
    将发送的信息打印输出，当双方收到quit的时候
    程序全部退出。

思考题：
    是否每次启动程序必须进行有名管道的创建工作
    能否有一个独立的维护工具，可以任意创建并删除
    有名管道？
    比如：
        ./fifo_tool -A fifo  ==>创建一个有名管道fifo
        ./fifo_tool -D fifo  ==>删除一个有名管道fifo

作业：

    有名管道的操作函数封装：
    int fifo_read(char *fifoname,void *s,int size);
    int fifo_write(char *fifoname,void *s,int size);

    编写测试程序验证以上两个函数效果。

    gstream

  有名管道 ===》

    1、是否需要同步，以及同步的位置。
        读端关闭 是否可以写，不能写什么原因。
        写端关闭 是否可以读。

        结论：有名管道执行过程过必须有读写端同时存在。
              如果有一端没有打开，则默认在open函数部分阻塞。

    2、有名管道是否能在fork之后的亲缘关系进程中使用。
        结论： 可以在有亲缘关系的进程间使用。
        注意： 启动的次序可能会导致其中一个稍有阻塞。

    3、能否手工操作有名管道实现数据的传送。
        读： cat  fifoname
        写： echo "asdfasdf" > fifoname

 

pin️‍灼灼灼灼
关注
linux——进程间通信IPC
a_zxswer的博客
12-18 511
Linux中七种IPC详解，进程间通信
Linux —— 进程间通信
weixin_59913110的博客
03-16 1053
1.数据传输：一个进程需要将它的数据发送给另一个进程2.资源共享：多个进程之间共享同样的资源3.通知事件：一个进程需要向另一个或一组进程发送消息，通知它们发生了某件事情(例如子进程退出时要通知父进程)4.进程控制：有些进程希望完全控制另一个进程的执行，此时控制进程希望能够拦截另一个进程的所有陷入和异常，并能够及时指导它的状态改变。
Linux进程间通信IPC的几种方式简介
Sunshine的专栏
05-27 7379
Linux进程通信的源头       linux下的进程通信手段基本上是从Unix平台上的进程通信手段继承而来的。而对Unix发展做出重大贡献的两大主力AT&T（原为American Telephone & Telegraph的缩写，也是中文译名美国电话电报公司由来）的贝尔实验室及BSD（加州大学伯克利分校的伯克利软件发布中心）在进程间通信方面的侧重点有所不同。前者对Unix早期的进程间通信手段
Linux下Socket通信（IPC）
LoveZhangjia521的专栏
08-17 352
1、Linux下的Socket通信是一种基于文件的IPC通信，也可以是基于其他设备的IPC通信。它可以在本机内不同进程间实现通信，也可以在实现不同主机之间的通信。 2、Socket是一种进程间通信模式： 对等模式（P2P）：一对一：UDP 客户服务器模式（C/S）：一对多：TCP 3、基本创建步骤 （1）通过socket()函数创建socket （2）通过bind函数绑定socket于...
Linux 进程间通信（IPC）
清欢Allen的技术博客
08-22 743
进程间通信（ipc), 指不同进程之间的信息传输或交换。
Linux Socket IPC
weixin_30565199的博客
09-16 150
Socket API原本是为网络通讯设计的，但后来在socket的框架上发展出一种IPC机制，就是UNIX Domain Socket。虽然网络socket也可用于同一台主机的进程间通讯（通过loopback地址127.0.0.1），但是UNIX Domain Socket用于IPC更有效率：不需要经过网络协议栈，不需要打包拆包、计算校验和、维护序号和应答等，只是将应用层数据从一个进程拷贝...
进程间通信——IPC（Linux）
kpl_20的博客
03-12 1204
匿名管道 脏数据 pipe 进程池 原子性 PIPE_BUF 命名管道 mkfifo ulimit -a 参数传参规范 unlink 日志 time localtime struct tm snprintf 可变参数(va_list va_start va_end) vsnprintf System V 共享内存 shmget ftok ipcs ipcrm shmat shmdt shmctl 消息队列 信号量 数据不一致问题 互斥 临界资源 临界区 二元信号量 对资源的预定机制 计数器 IPC
Linux——进程间通信
weixin_46107667的博客
05-04 453
进程间通信进程间通信进程间通信的本质进程间通信的目如何可以做到进程间通信进程间通信分类管道什么是管道?匿名管道管道的特点管道的四种情况命名管道匿名管道和命名管道的区别System V共享内存共享内存建立的过程共享内存函数共享内存特点消息队列信号量POSIX 进程间通信 进程间通信的本质 进程间通信的本质就是不同的进程可以看见同一份资源 进程间通信的目 数据传输：一个进程需要将它的数据发送给另外一个进程 资源共享：多个进程之间共享相同的资源 通知事件：一个进程需要向另外一个或者一组进程发送消息，通知发生
Linux基础 ——“进程间通信” 沟通是怎么连接的呢
weixin_44278698的博客
03-25 2913
文章目录进程间通信(IPC)篇一、进程间通信概述二、管道通信原理1. 管道（无名管道）：2. 管道 编程的实战：三、FIFO （命名管道）1. 创建FIFO有名管道代码：2. 当open一个FIFO时，是否设置非阻塞标志（O_NONBLOCK）的区别？3. 命名管道的数据通信编程实现： 进程间通信(IPC)篇 一、进程间通信概述 进程间通信是指在不同进程之间传播或交换信息，IPC的方式常有管道（包括无名管道和命名管道）消息队列，信号量，共享存储，Socket,Stream等。其中Socket和Stream支
Linux——进程间通信（IPC）
qq_46036601的博客
07-26 272
进程间通信（IPC）是指在不同进程间进行传播或交换信息。 进程间通信的方式主要有管道（包括无名管道和命名管道）、消息队列、共享内存、信号量等。 一、管道 管道通常指无名管道，是Unix系统IPC最古老的形式。 1.特点： 1.管道是单向的，有固定的写段和读端 2.只能用于具有亲缘关系的进程之间的通信 3.只存在于内存之中，是一种特殊文件，可使用普通的read、write等函数 4、管道中不储存数据，数据读完之后就没了 ...
linux IPC之socket解析及实例代码
01-10
Linux下的Socket通信是一种基于文件的IPC通信，也可以是基于其他设备的IPC通信。它可以在本机内不同进程间实现通信，也可以在实现不同主机之间的通信。 socket的创建步骤 服务端 1.通过socket()函数创建socket 2.通过bind函数绑定socket于设备地址 3.通过listen监听指定的socket 4.通过accept等待客户端的连接 客户端 1.通过socket()函数创建socket 2.通过connect连接到服务端 待经过上面的步骤后，服务端和客户端已经建立了链接，可以通过write/read或者sendto/recvfrom发送/接收数据
linux socket IPC（本地套接字domain）
m0_37132481的博客
06-17 233
linux socket IPC（本地套接字domain）_ShenHang_的博客-CSDN博客
linux socket编程(5):socket IPC
10-16 1991
socket IPC与一般网络通信一致，也有两种类型sock_stream 和sock_daram不同的地方在于： 1.网络通信server端以IP/Port作为服务名，IPC则以socket文件路径名作为服务名，socket文件与一般文件不同，socket文件是在程序运行时创
Linux学习总结（二十二）socket IPC（本地套接字domain）
bureau123的博客
03-18 330
  socket API原本是为网络通讯设计的，但后来在socket的框架上发展出一种IPC机制，就是UNIX Domain Socket，虽然网络socket也可用于同一台主机的进程间通讯(通过loopback地址127.0.0.1)，但是UNIX Domain Socket用于IPC更有效率：不需要经过网络协议栈，不需要打包拆包、计算校验、维护序号和应答等，只是将应用层数据从一个进程拷贝到另一个进程。这是因为，IPC机制本质上是可靠的通讯，而网络协议是为不可靠的通讯设计的。UNIX Domain Soc
linux客户服务端ipc,Linux下Socket通信（IPC）
weixin_42405371的博客
05-02 341
1、Linux下的Socket通信是一种基于文件的IPC通信，也可以是基于其他设备的IPC通信。它可以在本机内不同进程间实现通信，也可以在实现不同主机之间的通信。2、Socket是一种进程间通信模式：对等模式(P2P)：一对一：UDP客户服务器模式(C/S)：一对多：TCP3、基本创建步骤(1)通过socket()函数创建socket(2)通过bind函数绑定socket于设备地址(3)进行读写操...
Linux IPC之socket网络编程
qq_53022114的博客
08-15 301
一、之前的单机IPC回顾 管道--------------------->父子间通信 消息队列----------------->内核里经营一系列消息队列 共享内存----------------->内核创建一个共享内存 信号--------------------->A通过B的PID进程标识符给它发消息 信号量------------------->对临界资源，共享内存做PV操作 (特点：依赖于内核，造就功能缺陷，无法多机通信) 网络IPC（
Linux IPC之Socket网络编程基础篇
delphiwcdj的专栏
08-02 1806
UNIX IPC工具使用总结 里介绍了socket是一种用于通信的IPC工具。它允许位于同一主机或跨主机上的应用程序之间交换数据。第一个被广泛接受的socket API实现于1983年，出现在4.2BSD中，实际上这组API已经被移植到了所有UNIX实现以及大多数操作系统上。概述在一个典型的C/S场景中，应用程序使用socket进行通信的方式如下： 各个应用程序创建一个socket。socket是一
Linux系统编程-进程间通信（IPC）常用方式详解
最新发布
qq_42037383的博客
07-12 3181
进程间通信（IPC，Inter-Process Communication）是指在操作系统中，不同进程之间进行数据交换和信息传递的机制。这种通信允许正在运行的多个进程能够相互协作、共享数据或者进行同步操作，以实现更复杂的任务和功能。Linux环境下，进程地址空间相互独立，每个进程各自有不同的用户地址空间。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值