常連

# 状況と質問

Cで書かれたあるソースコード（**念のため一番下に載せておきます**）をコピペして動かしたいのですが、セグフォのエラーが出てしまいました。そこで最低限のものを書いて実験したところ、ループの途中でセグフォが出ていることがわかりました。

どうしてループの途中で、しかも決まった回数のときにsegmentation faultになるのでしょうか？　またそれを解決する方法はありますか？

初歩的な質問かもしれないことは承知ですが、調べるとっかかりになるワードだけでも構いませんので、ご回答いただければ助かります。

# コード

```C
// test2.h

#include <stdio.h>

struct udmabuf{
    char name[128];
    unsigned char * buf;
};
```

```C
// test1.c

#include <stdio.h>
#include "test2.h"

int main(){
    struct udmabuf intake_buf;
    float a[32 * 32]; 
    int i, j; // 行列の添字
    int m, n; // 行列のサイズ
    m = n = 32;
    for (i = 0; i < m*n; i++){ // 行列を初期化
        a[i] = i / 2.0; 
    }

    int count = 0;
    for (i = 0; i < m; i++){
        for (j = 0; j < n; j++){
            ((float *)(intake_buf.buf))[i * n + j] = a[i * n + j];
            printf("%d\n", count); // 420までで止まる。なぜ？？
            count = count + 1;
        }
    }

    return 0;
}

```

```bash
# 実行結果
$ gcc test1.c && ./a.out
1
2
3
...
418
419
420
Segmentation fault: 11
```

# 元にしている実際に動かしたいコード

```c
// dma_simple.h

#include <stdio.h>
#include <stdint.h>
#include <stdlib.h>
#include <unistd.h>
#include <fcntl.h>
#include <string.h>
#include <sys/types.h>
#include <sys/mman.h>

#define DMA_INTAKE_DMACR   (0x0000)
#define DMA_INTAKE_DMASR   (0x0004)
#define DMA_INTAKE_SA      (0x0018)
#define DMA_INTAKE_LENGTH  (0x0028)

#define DMA_OUTLET_DMACR   (0x0030)
#define DMA_OUTLET_DMASR   (0x0034)
#define DMA_OUTLET_DA      (0x0048)
#define DMA_OUTLET_LENGTH  (0x0058)

#define DMA_CR_RS      (1u<<0)
#define DMA_CR_RESET   (1u<<2)

#define DMA_SR_HALTED  (1u<<0)
#define DMA_SR_IDLE    (1u<<1)
#define DMA_SR_IOC_Irq (1u<<12)
#define DMA_SR_ERR_Irq (1u<<14)


static inline uint32_t regs_read32 (void* addr){
    volatile uint32_t* regs_addr = (uint32_t*)(addr);
    return *regs_addr;
}

static inline void regs_write32 (void* addr, uint32_t data){
    volatile uint32_t* regs_addr = (uint32_t*)(addr);
    * regs_addr = data;
}

static inline void dma_reset (void* regs){
    regs_write32(regs+DMA_INTAKE_DMACR, DMA_CR_RESET);
    while(regs_read32(regs+DMA_INTAKE_DMACR) & DMA_CR_RESET); // この構文謎い
    regs_write32(regs+DMA_OUTLET_DMACR, DMA_CR_RESET);
    while(regs_read32(regs+DMA_OUTLET_DMACR) & DMA_CR_RESET);
}

static inline void dma_setup (
        void* regs,
        unsigned long src_addr,
        unsigned long dst_addr
    ){
    regs_write32(regs + DMA_OUTLET_DMACR, DMA_CR_RS);
    regs_write32(regs + DMA_OUTLET_DA   , dst_addr);
    regs_write32(regs + DMA_INTAKE_DMACR, DMA_CR_RS);
    regs_write32(regs + DMA_INTAKE_SA   , src_addr);
}

static inline void dma_intake_start (void* regs, unsigned int xfer_size){
    regs_write32(regs + DMA_INTAKE_LENGTH, xfer_size);
}

static inline void dma_outlet_start (void* regs, unsigned int xfer_size){
    regs_write32(regs + DMA_OUTLET_LENGTH, xfer_size);
}

static inline void dma_wait_irq (void* regs){
    while (~regs_read32(regs + DMA_INTAKE_DMASR) & DMA_SR_IOC_Irq);
    while (~regs_read32(regs + DMA_OUTLET_DMASR) & DMA_SR_IOC_Irq);
}

static inline void dma_clear_status (void* regs){
    regs_write32(regs + DMA_INTAKE_DMASR, DMA_SR_IOC_Irq | DMA_SR_ERR_Irq);
    regs_write32(regs + DMA_OUTLET_DMASR, DMA_SR_IOC_Irq | DMA_SR_ERR_Irq);
}

struct udmabuf {
    char           name[128];
    int            file;
    unsigned char* buf;
    unsigned int   buf_size;
    unsigned long  phys_addr;
    unsigned long  debug_vma;
    unsigned long  sync_mode;
};

int udmabuf_open  (struct udmabuf* udmabuf, const char* name);
int udmabuf_close (struct udmabuf* udmabuf);
```

```c
// dma_simple.c

#include "dma_simple.h"

int udmabuf_open (struct udmabuf* udmabuf, const char* name){
    char file_name[1024];
    int fd;
    unsigned char attr[1024];

    strcpy(udmabuf -> name, name);
    udmabuf -> file = -1;

    // phys_addr
    sprintf(file_name, "/sys/class/u-dma-buf/%s/phys_addr", name);
    if (
            (fd = open(file_name, O_RDONLY)) == -1
        ){
        printf("Can not open %s\n", file_name);
        return (-1);
    }
    read(fd, (void*)attr, 1024);
    sscanf(attr, "%x", &udmabuf->phys_addr);
    close(fd);

    // size
    sprintf(file_name, "/sys/class/u-dma-buf/%s/size", name);
    if (
            (fd = open(file_name, O_RDONLY)) == -1
        ){
        printf("Can not open %s\n", file_name);
        return (-1);
    }
    read(fd, (void *)attr, 1024);
    sscanf(attr, "%x", &udmabuf -> buf_size);
    close(fd);

    sprintf(file_name, "/dev/%s", name);
    if (
            (udmabuf -> file = open(file_name, O_RDWR | O_SYNC)) == -1
        ){
        printf("Can not open %s\n", file_name);
        return (-1);
    }

    udmabuf -> buf = mmap(NULL, udmabuf -> buf_size, PROT_READ|PROT_WRITE, MAP_SHARED, udmabuf -> file, 0);
    udmabuf -> debug_vma = 0;
    udmabuf -> sync_mode = 1;

    return 0;
}

int udmabuf_close(struct udmabuf* udmabuf){
    if (udmabuf -> file < 0) return -1;

    close(udmabuf -> file);
    udmabuf -> file = -1;
    return 0;
}
```

```c
// matrix.c

#include "dma_simple.h"

void main(){
    int uio1_fd = open("/dev/uio4", O_RDWR);
    void *hls_regs = mmap(NULL, 0x1000, PROT_READ|PROT_WRITE, MAP_SHARED, uio1_fd, 0);

    int uio2_fd = open("/dev/uio5", O_RDWR);
    void *dma_regs = mmap(NULL, 0x1000, PROT_READ|PROT_WRITE, MAP_SHARED, uio2_fd, 0);

    struct udmabuf intake_buf;
    struct udmabuf outlet_buf;
    if (udmabuf_open(&intake_buf, "udmabuf0") == -1) exit (1);
    if (udmabuf_open(&outlet_buf, "udmabuf1") == -1) exit (1);

    dma_reset(dma_regs);
    regs_write32(hls_regs, 0x81);

    float a[32*32];
    float b[32*32];
    float c[32*32];
    float cref[32*32];
    int i, j, t;
    int m, n, k;
    m = n = k = 32;

    for (i = 0; i < m*n; i++){
        a[i] = (float) i/2.0;
        b[i] = (float) i/3.0;
        c[i] = (float) 0;
    }

    for (i = 0; i < m; i++){
        for (j = 0; j < n; j++){
            ((float *)(intake_buf.buf))[i*n + j] = a[i*n + j];
        }
    }
    for (i = 0; i < m; i++){
        for (j = 0; j < n; j++){
            ((float *)(intake_buf.buf))[i*n + j + m*m] = b[i*n + j];
        }
    }

    dma_setup(dma_regs, intake_buf.phys_addr, outlet_buf.phys_addr);

    dma_outlet_start(dma_regs, m*m*4);
    dma_intake_start(dma_regs, m*m*2*4);

    dma_wait_irq(dma_regs);
    dma_clear_status(dma_regs);

    for (i = 0; i < m; i++){
        for (j = 0; j < n; j++){
            c[i*n + j] = ((float*)(outlet_buf.buf))[i*n + j];
        }
    }

    for (i = 0; i < m; i++){
        for (j = 0; j < n; j++){
            float sum = 0;
            for (t = 0; t < k; t++){
                sum += a[i*k + t] * b[t*n + j];
            }
            cref[i*n + j] = sum;
        }
    }

    int cnt_ok = 0;
    int cnt_ng = 0;
    for (i = 0; i < m*m; i++){
        if (c[i] == cref[i]){
            cnt_ok++;
        } else {
            printf("NG: hw %f, sw %f\n", c[i], cref[i]);
            cnt_ng++;
        }
    }
    printf("OK: %d, NG: %d, Total: %d\n", cnt_ok, cnt_ng, m*m);
    udmabuf_close(&outlet_buf);
    udmabuf_close(&intake_buf);
    close(uio2_fd);
    close(uio1_fd);
}
```

【C言語】ループの途中でSegmentation faultが出る

引数nから値を求める簡単なプログラムを作成しましたが、
以下のプログラムでセグメンテーション違反がでます。
大きな数字の用いた時にコアダンプが生じます。
lldbを用いてデバッグしたところ、
func関数の返り値のところでbreakしていました。
ここまではわかったのですが、ここから先の解決方法がわかりません。
ご回答よろしくおねがいいたします。

```c++
#define ffor(i,a,b) for (int i=(a);i<(b);i++)
#define rfor(i,a,b) for (int i=(b)-1;i>=(a);i--)
#define rep(i,n) for (int i=0;i<(n);i++)
#define rrep(i,n) for (int i=(n)-1;i>=0;i--)
#include<iostream>
#include<iomanip>
#include<algorithm>
#include<cmath>
#include<string>
#include<stack>
#include<queue>
#define SIZE 10000001
#define MOD 1000000007
#define INF 100000000
using namespace std;

int memo[SIZE];
int s = 10007;
int func(int n){
	if(n == 3) return 1;
	if(n <= 2) return 0;
	if(memo[n] != 0) return memo[n];

	return memo[n] = (func(n-1)+func(n-2)+func(n-3))%s;
}

int main(){
	int n;
	cin >> n;

	cout << func(n) << endl;

	return 0;
}

```


追記
記入不足があり申し訳有りません。
SIZE以上の入力が出た時にコアダンプが出るという点は承知しております。
入力値が10^4程度だとエラーが出ないのですが、10^6くらいの値からエラーが出ます。

セグメンテーションエラーが消えない

### リスト構造への追加
画面から場所とデータを入力し、リスト構造にデータを追加するプログラムを作りました。
しかしコンパイルは通ったのですが実行するとセグメンテーション違反と表示されてしまいます。
どこがおかしいのでしょうか。教えて欲しいです。
よろしくおねがいします。

### 該当のソースコード

```c言語
#include <stdio.h>
#include <stdlib.h>

#define FILENAME "data_2105.txt"

struct LIST {
  int score;
  struct LIST *next;
};
typedef struct LIST LIST;


// リストを表示する関数
void  show_list(LIST *lh){
  LIST *p;
  p=lh;
  while(p != NULL){
    printf(" -> %d" , p->score);
      p=p->next;
} 
  printf("\n");
}


int main( void ) {
  int dat;
  int place,data,i;
  LIST *listhead = NULL;  // リストの先頭へのポインタ
  LIST *listtail = NULL;  // リストの末尾へのポインタ
  LIST *p,*q,*r,*temp;                // 一時ポインタ
  FILE *fp;               // ファイルポインタ

  // ファイルを開く
  if ( ( fp = fopen( FILENAME, "r" ) ) == NULL ) {
    fprintf( stderr,"ファイルが開けません\n" );
    exit( 1 );
  }


  // データを読み込み、構造体リストに格納する
  while( fscanf( fp, "%d",  &dat) != EOF ) {

    // 構造体を1個準備し，データを入力する
    p = ( LIST * )malloc( sizeof( LIST ) );
    p->score = dat;
    p->next = NULL;
    
    // 1個目のデータのときはリストの先頭に接続する，同時に末尾も登録する
    if ( listhead == NULL ) {
      listhead=p;
      listtail=p;
      
    }
    // 2個目以降のデータのときはリストの末尾に接続する
    else {
      listtail->next=p;
      listtail=p;
      
    }
  }

  // リストに格納されたデータを表示する
  show_list( listhead );

  //リストへの追加
do{
//データの読み込み
  printf("挿入場所(-1で終了) ; ");
  scanf("%d" , &place);
  printf("データ ; ");
  scanf("%d" , &data);
   r = ( LIST * )malloc( sizeof( LIST ) );
   r->score=data;
   r->next=NULL;
//場所が最初の場合
  if(place==0){
    temp=listhead;
    listhead=r;
    listhead->next=temp;
 show_list( listhead );
  }else{
//場所が最初以外の場合
for(i=0;i<=place-1;i++){
  if(i==0){
 temp=listhead;
 temp=r;
 listtail=r;
  }
   temp= temp->next;
}
 r->next=temp->next;
 temp->next=r;
show_list( listhead );
}
  
 }while(place !=-1);
  // リストのメモリを開放する
  while(p != NULL){
    q=p->next;
    free(p);
    p=q;
}
  while(r !=NULL){
    q=r->next;
    free(r);
    r=q;
}

  // ファイルを閉じる
  fclose( fp );
  return 0;
}
```

c言語　リスト構造への追加

スタックオーバーフローを実験するために、
ubuntu14.04 64bit, GDB 7.7.1, GCC 4.8を使って以下のプログラムを実行しました。
aslrはオフにしてあります。
```C
#include <stdio.h>
#include <string.h>

void bug(char *arg1){
    char name[128];
    strcpy(name,arg1);
    printf("Hello %s\n", name);
}

int main(int argc, char **argv){
    if(argc < 2){
        printf("Usage: %s <your name>\n", argv[0]);
        return 0;
    }
    bug(argv[1]);
    return 0;
}

```
これを-fno-stack-protectorオプションを付けてコンパイルしました。
そしてgdbにて
r `perl -e 'print "A"x144'`
で実行しました。
```
(gdb) r `perl -e 'print "A"x144'`
Starting program: /home/----/-------/bug `perl -e 'print "A"x144'`
Hello AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA

Program received signal SIGSEGV, Segmentation fault.
0x00000000004005bc in bug ()
(gdb) c
Continuing.

Program terminated with signal SIGSEGV, Segmentation fault.
The program no longer exists.
(gdb) 

```
すると、以上のような結果が帰ってきました。
handle SIGSEGV nostop にしても同様の結果になりました。
なぜ、bug()から0x4141414141414141に飛んでくれないのでしょうか？
回答よろしくお願いします。


また、bugのアセンブラは以下になります。

```
---------:~/----------$ gdb -q bug
Reading symbols from bug...(no debugging symbols found)...done.
(gdb) disas bug
Dump of assembler code for function bug:
   0x000000000040057d <+0>:	push   rbp
   0x000000000040057e <+1>:	mov    rbp,rsp
   0x0000000000400581 <+4>:	sub    rsp,0x90
   0x0000000000400588 <+11>:	mov    QWORD PTR [rbp-0x88],rdi
   0x000000000040058f <+18>:	mov    rdx,QWORD PTR [rbp-0x88]
   0x0000000000400596 <+25>:	lea    rax,[rbp-0x80]
   0x000000000040059a <+29>:	mov    rsi,rdx
   0x000000000040059d <+32>:	mov    rdi,rax
   0x00000000004005a0 <+35>:	call   0x400450 <strcpy@plt>
   0x00000000004005a5 <+40>:	lea    rax,[rbp-0x80]
   0x00000000004005a9 <+44>:	mov    rsi,rax
   0x00000000004005ac <+47>:	mov    edi,0x400694
   0x00000000004005b1 <+52>:	mov    eax,0x0
   0x00000000004005b6 <+57>:	call   0x400460 <printf@plt>
   0x00000000004005bb <+62>:	leave  
   0x00000000004005bc <+63>:	ret    
End of assembler dump.
(gdb) 

```

gdbのSIGSEGVについて

c言語でプログラムを作っているのですが、構造体の中のポインタを参照するとセグメンテーション違反と出ました。

調べてみたらこんな記事があって解決方法も載ってました。
http://oshiete.goo.ne.jp/qa/3144134.html
この中の4の回答者様と同じようにたぶん実態がないんだと思います。

そこでいろいろ試してみてこういうものを作ったのですが、こうするとprintfで変な値を指しています。たぶん環境によって変わると思いますが、自分の場合は./a.outを指していました。

この挙動はなぜ起こるのですか？また、このように別の関数で構造体を宣言して、その後、別の関数からポインタで参照する方法を教えてください。

お願いします。

```c
#define DEBUG

 #include<stdio.h>

 #include<stdlib.h>



struct Sort{

    int no;

    char *name;

    

    char *avg;

    //char *maximax;

    char *saiaku_saidai;

    

    char *alias;

};
void sortinit(struct Sort *);

int main(void){
struct Sort *arr;
void *fes;

sortinit(arr);
//struct Sort *aa=(struct Sort *)fes;

    printf("%s",arr->name);

    return 0;  

}

 void sortinit(struct Sort *in){
   struct Sort sortArr[]={

            {

                1,"バブルソート","nasi","n^2","基本交換法"

            },{

                2,"選択ソート","n^2","n^2","基本三法"

            },{

                3,"挿入ソート","n+d","n^2","基本三法"

            },{

                4,"シェルソート","nasi","nlog^2n",""

            },{

                5,"マージソート","nlogn","nlogn",""

            },{

                6,"ヒープソート","nlogn","nlogn",""

            },{

                7,"クイックソート","nlogn","n^2",""

            },{

                8,"ただの(偏った)二分木","n+1/2","n","線形探索法"

            },{

                9,"完全二分木","","",""

            },{

                10,"2分探索法","","",""

            }

    };
in=sortArr;
//struct Sort *in2=(struct Sort *)in;

}
```

C言語 構造体とポインタでセグメンテーション違反

お世話になります。
以下の内容で困っておりまして、解決方法をご存じの方、
アドバイスやご教示を頂けますでしょうか。

### 実現したいこと
Cのlibwebsocketsにてwebsocketサーバを作成しています。
接続クライアントごとにクライアントから受け取ったユーザID(42バイト想定)を保持したいと考えています。

### 発生している問題・エラーメッセージ
下記のソースコードで実現しようとしています。
しかし、クライアントからユーザIDの登録済みかをリクエストすると、
「Segmentation fault (core dumped)」が表示され、
websocketサーバが強制終了してしまします。
※本ソースコードはクライアントID保持の機能を持たせる前は正常に機能していました。
```
#./wstest
[2023/06/03 13:50:54:8713] N: lws_create_context: LWS: 4.3.99-v4.3.0-276-ge8eb7d6, NET CLI SRV H1 H2 WS SS-JSON-POL ConMon IPv6-absent
[2023/06/03 13:50:54:8715] N: __lws_lc_tag:  ++ [wsi|0|pipe] (1)
[2023/06/03 13:50:54:8715] N: __lws_lc_tag:  ++ [vh|0|netlink] (1)
[2023/06/03 13:50:54:8716] N: __lws_lc_tag:  ++ [vh|1|default||40000] (2)
[2023/06/03 13:50:54:8716] N: [vh|1|default||40000]: lws_socket_bind: source ads 0.0.0.0
[2023/06/03 13:50:54:8716] N: __lws_lc_tag:  ++ [wsi|1|listen|default||40000] (2)
Starting server...
[2023/06/03 13:51:09:2695] N: __lws_lc_tag:  ++ [wsisrv|0|default|(null)] (1)
Assigned Client
Request message: SelReg,0xa7d206f33e6AaC9BD33d5EA943EE30fAaec9838F,5B11
Segmentation fault (core dumped)
```

### ソースコード(抜粋)
※全てのソースコードは、「ソースコード(全て)」にに乗せています。

クライアントデータを保持する構造体はグローバルで定義しています。
```
// クライアントデータ構造体
struct ClientData {
  char userId[256];
};
```

クライアントデータ構造体はcallback_echoの引数userのメモリを使用して初期化しています。
```
static int callback_echo(struct lws *wsi, enum lws_callback_reasons reason, void *user, void *in, size_t len) {

  char *methodName;
  char *userId;
  char *responseData = NULL;

  // userのポインタを使用
  struct ClientData *client_data = (struct ClientData *)user;

  [省略]
}
```

クライアントから対象のユーザIDがMySQLに登録済みかのリクエスト受けとり次第、
MySQLに問い合わせて、登録済の場合はユーザIDを保持しています。
```
static int callback_echo(struct lws *wsi, enum lws_callback_reasons reason, void *user, void *in, size_t len) {

  [省略]

  switch (reason) {
     [省略]

    case LWS_CALLBACK_RECEIVE: {
      char *message = (char*)in;
      printf("Request message: %s\n", message);

      methodName = strtok(message, ",");

      // 登録済みか確認
      if(strcmp(methodName, "SelReg") == 0)
      {
        userId = strtok(NULL, ","); // 42バイト文字列想定

        char response[255];
        int result = SelectRegist(userId, response); // MySQLに問い合わせ(スタブ)

        // 登録済みユーザ
        if(result == 0){
          strncpy(client_data->userId, userId, sizeof(client_data->userId) - 1); // ユーザIDを保持
        // エラー
        }else if (result == 1) {
          snprintf(response, sizeof(response), "1");
        // 未登録ユーザ
        }else if (result == 2) {
          snprintf(response, sizeof(response), "2");
        }

        printf("SelReg: %d\n", result);
        lws_write(wsi, (unsigned char*)response, strlen(response), LWS_WRITE_TEXT);
      }

      break;
    }

     [省略]
  }

   [省略]
}
```

### ソースコード(全て)

申し訳ありません。teratailの文字数制限超過の為下記URLでご確認ください。
http://160.251.81.206/teratail/20230603/wstest.c

### 試したこと
gdbでコアダンプのバックトレースを出力しました。
wstest.cの46行目でセグメンテーションフォルトが発生しているようですが、
その改修方法が分からない状態です。

```
(gdb) bt full
#0  0x00007f59fbbc3e1b in __strncpy_sse2_unaligned () from /lib64/libc.so.6
No symbol table info available.
#1  0x0000000000400a5e in callback_echo (wsi=0x8fdab0, reason=LWS_CALLBACK_RECEIVE, user=0x0, in=0x8f69f6,
    len=50) at wstest.c:46
        response = '\000' <repeats 16 times>, "\200\221\033\375Y\177", '\000' <repeats 14 times>, "\b", '\000' <repeats 19 times>, "\300\302<\375Y\177\000\000\000\000\000\000\000\000\000\000 \324<\375Y\177\000\000\000\000\000\000\000\000\000\000\037\325<\375Y\177\000\000\354\363\032\375\000\000\000\000\300\302<\375Y\177\000\000\000\000\000\000\020", '\000' <repeats 11 times>, "\320\001_\361\374\177\000\000\tB\023\375Y\177\000\000\b\001_\361\374\177\000\000\000\000\000\000\000\000\000\000\200\221\033\375Y\177\000\000\000\000\000\000\b", '\000' <repeats 11 times>, "\020\000\000\000\060\000\000\000\340\001_\361\374\177\000\000"...
        result = 0
        message = 0x8f69f6 "SelReg"
        methodName = 0x8f69f6 "SelReg"
        userId = 0x8f69fd "0xa7d206f33e6AaC9BD33d5EA943EE30fAaec9838F"
        responseData = 0x0
        client_data = 0x0
#2  0x00007f59fd165253 in user_callback_handle_rxflow () from /usr/local/lib/libwebsockets.so.19
No symbol table info available.
#3  0x00007f59fd194686 in lws_ws_frame_rest_is_payload () from /usr/local/lib/libwebsockets.so.19
No symbol table info available.
#4  0x00007f59fd1947d0 in lws_parse_ws () from /usr/local/lib/libwebsockets.so.19
No symbol table info available.
#5  0x00007f59fd1807c8 in lws_read_h1 () from /usr/local/lib/libwebsockets.so.19
No symbol table info available.
#6  0x00007f59fd18f58b in rops_handle_POLLIN_ws () from /usr/local/lib/libwebsockets.so.19
No symbol table info available.
#7  0x00007f59fd163967 in lws_service_fd_tsi () from /usr/local/lib/libwebsockets.so.19
No symbol table info available.
#8  0x00007f59fd121522 in _lws_plat_service_forced_tsi () from /usr/local/lib/libwebsockets.so.19
No symbol table info available.
#9  0x00007f59fd12192e in _lws_plat_service_tsi () from /usr/local/lib/libwebsockets.so.19
No symbol table info available.
#10 0x00007f59fd121991 in lws_plat_service () from /usr/local/lib/libwebsockets.so.19
No symbol table info available.
#11 0x00007f59fd163b2f in lws_service () from /usr/local/lib/libwebsockets.so.19
No symbol table info available.
#12 0x0000000000400b73 in main () at wstest.c:107
        info = {iface = 0x0, protocols = 0x6020a0 <protocols>, extensions = 0x0, token_limits = 0x0,
          http_proxy_address = 0x0, headers = 0x0, reject_service_keywords = 0x0, pvo = 0x0,
          log_filepath = 0x0, mounts = 0x0, server_string = 0x0, error_document_404 = 0x0, port = 40000,
          http_proxy_port = 0, max_http_header_data2 = 0, max_http_header_pool2 = 0, keepalive_timeout = 0,
          http2_settings = {0, 0, 0, 0, 0, 0, 0}, max_http_header_data = 0, max_http_header_pool = 0,
          ssl_private_key_password = 0x0, ssl_cert_filepath = 0x0, ssl_private_key_filepath = 0x0,
          ssl_ca_filepath = 0x0, ssl_cipher_list = 0x0, ecdh_curve = 0x0, tls1_3_plus_cipher_list = 0x0,
          server_ssl_cert_mem = 0x0, server_ssl_private_key_mem = 0x0, server_ssl_ca_mem = 0x0,
          ssl_options_set = 0, ssl_options_clear = 0, simultaneous_ssl_restriction = 0,
          simultaneous_ssl_handshake_restriction = 0, ssl_info_event_mask = 0, server_ssl_cert_mem_len = 0,
          server_ssl_private_key_mem_len = 0, server_ssl_ca_mem_len = 0, alpn = 0x0,
          client_ssl_private_key_password = 0x0, client_ssl_cert_filepath = 0x0, client_ssl_cert_mem = 0x0,
          client_ssl_cert_mem_len = 0, client_ssl_private_key_filepath = 0x0, client_ssl_key_mem = 0x0,
          client_ssl_ca_filepath = 0x0, client_ssl_ca_mem = 0x0, client_ssl_cipher_list = 0x0,
          client_tls_1_3_plus_cipher_list = 0x0, ssl_client_options_set = 0, ssl_client_options_clear = 0,
          client_ssl_ca_mem_len = 0, client_ssl_key_mem_len = 0, provided_client_ssl_ctx = 0x0,
          ka_time = 0, ka_probes = 0, ka_interval = 0, timeout_secs = 0, connect_timeout_secs = 0,
          bind_iface = 0, timeout_secs_ah_idle = 0, tls_session_timeout = 0, tls_session_cache_max = 0,
          gid = 0, uid = 0, options = 0, user = 0x0, count_threads = 0, fd_limit_per_thread = 0,
          vhost_name = 0x0, external_baggage_free_on_destroy = 0x0, pt_serv_buf_size = 0, fops = 0x0,
          foreign_loops = 0x0, signal_cb = 0x0, pcontext = 0x0, finalize = 0x0, finalize_arg = 0x0,
          listen_accept_role = 0x0, listen_accept_protocol = 0x0, pprotocols = 0x0, username = 0x0,
          groupname = 0x0, unix_socket_perms = 0x0, system_ops = 0x0, retry_and_idle_policy = 0x0,
          register_notifier_list = 0x0, pss_policies_json = 0x0, pss_plugins = 0x0, ss_proxy_bind = 0x0,
          ss_proxy_address = 0x0, ss_proxy_port = 0, txp_ops_ssproxy = 0x0, txp_ssproxy_info = 0x0,
          txp_ops_sspc = 0x0, rlimit_nofile = 0, early_smd_cb = 0x0, early_smd_opaque = 0x0,
          early_smd_class_filter = 0, smd_ttl_us = 0, smd_queue_depth = 0, fo_listen_queue = 0,
          event_lib_custom = 0x0, log_cx = 0x0, http_nsc_filepath = 0x0, http_nsc_heap_max_footprint = 0,
          http_nsc_heap_max_items = 0, http_nsc_heap_max_payload = 0, _unused = {0x0, 0x0}}
        context = 0x8f6010
        n = 0
        ret = 0
(gdb)
```

以上になります。
よろしくお願いします。

Cのwebsocketサーバにて、クライアントから受け取ったIDをグローバル変数に保持できない。

###　正しく値が表示されるようにしたい

c言語で正の整数を入力し小さい順に並べるというリスト構造を再帰を用いて作りたいのですが以下の問題が発生してしまいます。
 10行目の (*q)->data = a;　がうまく作動していないのことがわかったのですがうまく行きません。
原因と解決法を教えてほしいです。

### 発生している問題・エラーメッセージ

```
正の値の入力しても何も表示されない。
負の値を入力するとセグメンテーションエラーが発生する。
(例)
0以上のデータを入力して下さい(負の値で終了) -->4

0以上のデータを入力して下さい(負の値で終了) -->-1
セグメンテーション違反です


```

### 該当のソースコード

```c
#include<stdio.h>
#include<stdlib.h>

struct cell{
  double data;
  struct cell *next;
};

void add_list(struct cell **q, double a){
  if((*q)->next == NULL){
    (*q)->data = a;
  }
  if((*q)->data < a){
    add_list(&(*q)->next,a);
  }
  else{
    (*q)->data = a;
  }
}

void show_list(struct cell **q ){
  if((*q)->next == NULL){
    printf("\n");
  }
  else{
    printf("-> %lf" , (*q)->data);
    show_list(&(*q)->next);
  }
}

void free_list(struct cell *q ){
  if(q->next != NULL){
    free_list(q->next);
  }
  free(q);
}


int main(void){
 double data;
 struct cell *p;
 (*p).next = NULL;

  while(1){
    printf("0以上のデータを入力して下さい(負の値で終了) -->");
    scanf("%lf" , &data);
    if(data < 0){
      free_list(p);
    }
    else{
      add_list(&p,data);
      show_list(&p);
    } 

  }

  return 0;
}

```

### 試したこと

gdbコマンドによる値の確認

c言語　再帰を用いたリスト構造でのエラー

C言語で2分木を使った昇順ソートアルゴリズムを作成しています。
小さい順に表示しようとするとセグメンテーション違反が起こってしまいます。原因がわからないので教えていただきたいです。

### ソース

```
#include <stdio.h>
#include <stdlib.h>
#include <string.h>


struct tree {
    int value;
    struct tree *left;
    struct tree *right;
};

// ノードを追加
int append(int input, struct tree *current_node) {
    if (input < current_node->value) {
        if (current_node->left != NULL) {
            append(input, current_node->left);
        } else {
            struct tree new = {input, NULL, NULL};
            current_node->left = &new;
        }
    
    } else {
        if (current_node->right != NULL) {
            append(input, current_node->right);
        } else {
            struct tree new = {input, NULL, NULL};
            current_node->right = &new;
        }
    }
}


// 小さい順に表示
void sort(struct tree *current_node) {
    if (current_node->left != NULL) {
        sort(current_node->left);
    }
    printf("%d, ", current_node->value);
    if (current_node->right != NULL) {
        sort(current_node->right);
    }
}



int main() {
    int sequence[] = {2, 4, 6, 1, 8, 2, 10, 0};
    int n = sizeof(sequence) / sizeof(int);
    struct tree root = {
        sequence[0],
        NULL,
        NULL
    };
    for (int i = 1; i < n; i++) {
        append(sequence[i], &root);
    }
    sort(&root);
    printf("\n");
}
```

### 発生している問題・エラーメッセージ
sort()関数のところでセグメンテーション違反が起こっています。


### 試したこと
gdbでステップ実行をしてみたのですが、sort()にはいった段階でそれぞれのノードのvalueの値が-129660088のようにおかしくなっていました。


### 環境
WSL2, Ubuntu20.04LTS, gcc version9.3.0,