def record_event():
try:
print du.get_current_date_string(), '##开始检查在线状态'
device_info = Detector.objects.all()
if device_info.exists():
for device in device_info:
old_online_status = device.is_online
if (du.get_current_time() - (device.heartbeat_time if device.heartbeat_time is not None else (du.get_current_time() - timedelta(minutes=over_time_minute+1)))) > timedelta(minutes=over_time_minute) \
and (du.get_current_time() - (device.last_warning_time if device.last_warning_time is not None else (du.get_current_time() - timedelta(minutes=over_time_minute+1)))) > timedelta(minutes=over_time_minute):
print '####设置%s状态为离线' % device.device_id
Detector.objects.filter(id=device.id).update(
is_online=False)
if old_online_status:
online_event = {
'device_id': device.device_id,
'event': '离线',
'time': du.get_current_date_string()
}
serialize = DetectorOnlineEventSerializer(
data=online_event)
if serialize.is_valid():
serialize.save()
print '####device_id:', device.device_id, '保存离线事件'
else:
print '####device_id:', device.device_id, '保存离线事件', serialize.errors
center_report_detector_running_status(
device_id=device.device_id, device_is_online=0)
else:
print '设置%s状态为在线' % device.device_id
Detector.objects.filter(id=device.id).update(
is_online=True)
if not old_online_status:
online_event = {
'device_id': device.device_id,
'event': '上线',
'time': du.get_current_date_string()
}
serialize = DetectorOnlineEventSerializer(
data=online_event)
if serialize.is_valid():
serialize.save()
print '####device_id:', device.device_id, '保存上线事件'
else:
print '####device_id:', device.device_id, '保存上线事件', serialize.errors
center_report_detector_running_status(
device_id=device.device_id, device_is_online=1)
print '##检查在线状态完毕'
except Exception as e:
print e.message, e.args
def reset_user_password(request):
"""
重置用户密码
:param request:
:return:
"""
try:
request_data = common.print_header_data(request)
user_data = lc.trans_user_change_password(request_data)
user = User.objects.get(id=user_data['id'])
username = user.username
if user is not None:
user.set_password(str(su.get_md5('123456')).upper())
user.save()
User.objects.filter(username=username).update(
last_update_time=du.get_current_time())
common.generate_system_log(request_data, u' 用户操作', u'重置密码操作',
username + u'重置密码成功')
return common.ui_message_response(200, '修改密码成功', "success",
status.HTTP_200_OK)
else:
common.generate_system_log(request_data, u' 用户操作', u'重置密码操作',
username + u'重置密码失败')
return common.ui_message_response(400, '用户不存在', '用户不存在')
except Exception:
traceback.print_exc()
return common.ui_message_response(
500, '服务器内部错误', '服务器内部错误', status.HTTP_500_INTERNAL_SERVER_ERROR)
def user_change_password(request):
"""
修改用户密码
:param request:
:return:
"""
try:
request_data = common.print_header_data(request)
user_data = lc.trans_user_change_password(request_data)
print user_data
username = user_data['username']
user = auth.authenticate(**{
'username': username,
'password': user_data['old_password']
})
if user is not None:
user.set_password(user_data['new_password'])
user.save()
User.objects.filter(username=username).update(
last_update_time=du.get_current_time())
common.generate_system_log(request_data, u' 用户操作', u'修改密码操作',
username + u'修改密码成功')
return common.ui_message_response(200, '修改密码成功', "success",
status.HTTP_200_OK)
else:
common.generate_system_log(request_data, u' 用户操作', u'修改密码操作',
username + u'修改密码失败')
return common.ui_message_response(400, '原密码输入错误', '原密码输入错误')
except Exception:
traceback.print_exc()
return common.ui_message_response(
500, '服务器内部错误', '服务器内部错误', status.HTTP_500_INTERNAL_SERVER_ERROR)
def generate_system_log(request_data, event_type, opt_type, message):
from audit.audit_serializers import AuditManagementSerializer
audit_log = {
'log_id': str(snowflake.next_id(3, 3)),
'user': request_data.get('uuid', ''),
'time': du.get_current_time(),
'event_type': event_type,
'opt_type': opt_type,
'message': message,
'is_send_command': 0
}
serializer = AuditManagementSerializer(data=audit_log) # 序列化
if serializer.is_valid():
serializer.save() # 存储数据库
# 写入文件
file_dir = os.path.join(config.const.DISPOSAL_DIR, 'audit')
if not os.path.exists(file_dir):
os.makedirs(file_dir)
file_name = 'center_audit_' + str(int(time.time())) + '_' + str(1)
file_path = os.path.join(file_dir, file_name)
f_handler = open(file_path, 'wb')
f_handler.write(config.const.DISPOSAL_BOUNDARY + '\n')
f_handler.write('User-Agent:' + CENTER_USER_AGENT + '\n')
f_handler.write('Type:center_audit\n')
audit_log['time'] = audit_log['time'].strftime('%Y-%m-%d %H:%M:%S')
f_handler.write(json.dumps(audit_log))
f_handler.close()
else:
print '数据库操作失败'
def user_login(request):
"""
登录校验
:param request:
:return:
"""
try:
result = {}
user_data = {}
role_result = {}
request_data = common.print_header_data(request)
username = request_data.get('username')
# user_data['username'] = '******'
# username = '******'
user_data['username'] = username
password = request_data.get('password')
# user_data['password'] = str(su.get_md5('123456')).upper()
# password = str(su.get_md5('123456')).upper()
user_data['password'] = password
if User.objects.filter(username=username):
user = auth.authenticate(**user_data)
if user:
# django.contrib.auth.login(request, user)
result['username'] = user_data['username']
user_query = User.objects.filter(username=result['username'])
user_query.update(last_login=du.get_current_time())
group_query = user_query[0].groups.all()
for group in group_query:
permission_id_list = []
permission_query = group.permissions.all()
for permission in permission_query:
permission_id_list.append(permission.id)
role_result[group.name] = permission_id_list
result['role'] = role_result
common.generate_system_log(request_data, u'用户操作', u'登录操作',
username + u'登录成功')
result['flag'] = "success"
print "login result:", result
return common.ui_message_response(200, '登录成功', result,
status.HTTP_200_OK)
else:
common.generate_system_log(request_data, u'用户操作', u'登录操作',
username + u'密码错误')
return common.ui_message_response(400, '密码错误', '密码错误')
else:
common.generate_system_log(request_data, u'用户操作', u'登录操作',
u'用户名不存在')
return common.ui_message_response(400, '用户名不存在', '用户名不存在')
except Exception:
traceback.print_exc()
common.generate_system_log(request_data, u'用户操作', u'登录操作', u'登录模块出现异常')
return common.ui_message_response(
500, '服务器内部错误', '服务器内部错误', status.HTTP_500_INTERNAL_SERVER_ERROR)
def is_pwd_expire(request):
try:
request_data = common.print_header_data(request) # 获取请求数据
# 获取请求参数
login_id = request_data.get('username') # 用户id
if login_id is not None:
query_data = User.objects.filter(username=login_id)
now_time = du.get_current_time()
if now_time - query_data[0].last_update_time >= common.EXPIRE_TIME:
# is_expire = 1
is_expire = 0
else:
is_expire = 0
return common.ui_message_response(
200, '过期' if is_expire == 1 else '未过期', is_expire,
status.HTTP_200_OK)
else:
return common.ui_message_response(400, '没有username参数', "参数为空")
except Exception:
traceback.print_exc()
return common.ui_message_response(
500, '服务器内部错误', '服务器内部错误', status.HTTP_500_INTERNAL_SERVER_ERROR)
def process_communication_relation_upload(request, file_relative_path):
try:
# request_data = common.print_header_data(request) # 获取请求数据
# send_file = request.body
request_id = snowflake.next_id(1, 0) # 确定请求的全局唯一ID
detector_id = common.check_detector_available(request, Detector) # 检查检测器是否合法，合法就返回检测器ID
if isinstance(detector_id, Response):
return detector_id
# 日志记录
# logger_record.info('%s %s %s %d' % (request.META.get('REMOTE_ADDR'), detector_id, 'net_log', len(request.FILES)))
log_str = '%s %s %s %s %d' % (request.META.get('REMOTE_ADDR'), request.META.get('HTTP_X_REMOTE_ADDR', '0.0.0.0'), detector_id, 'net_log', len(request.FILES))
fu.string2log_append_per_day(content=log_str, path=common.LOG_PATH + 'detector_access_log/')
file_desc = request.META.get('HTTP_CONTENT_FILEDESC') # 请求头中的数据字段
file_desc = common.check_detector_upload_header_filedesc_field(file_desc) # 校验Content-Filedesc字段
if isinstance(file_desc, Response):
return file_desc
print 'file_desc:', pu.pretty_print_format(file_desc)
if len(request.FILES) == 1: # 上传一个gzip压缩文件
file_absolute_path = os.path.join(common.MEDIA_ROOT, file_relative_path) # 绝对路径（没有文件名）
request_file = request.FILES.values()[0]
gzip_f = gzip.GzipFile(mode='rb', fileobj=request_file)
try:
gzip_f.readline() # 尝试gzip读取文件，若无法读取则不是gzip格式文件
request_file.seek(0) # 将文件流重置偏移为文件开头
gzip_f.close() # 关闭文件流
except IOError:
gzip_f.close() # 关闭文件流
request_file.close()
return common.detector_message_response(400, '不是一个gzip压缩文件',
request_file.name + ' not a gzipped file')
file_name = request_file.name # 原始文件名
save_file_name = common.rename_detector_upload_file(detector_id, file_name) # 存储文件名
is_success = fu.handle_upload_file(file_absolute_path, request_file, save_file_name) # 上传文件
if is_success: # 没有重名文件，上传成功
request_file.close() # 关闭文件流
file_path = os.path.join(file_absolute_path, save_file_name)
# 生成业务处置系统所需文件（原始文件）
if config.const.UPLOAD_BUSINESS_DISPOSAL:
try:
# common.generate_business_file('net_log', file_path, detector_id + '_' + str(int(time.time())) + '_' + str(1) + '.gz')
if not os.path.exists(config.const.DISPOSAL_DIR + 'net_log/'):
os.makedirs(config.const.DISPOSAL_DIR + 'net_log/')
shutil.copy(file_path, config.const.DISPOSAL_DIR + 'net_log/' + detector_id + '_' + file_desc['checksum'])
# pass
except:
traceback.print_exc()
save_data = {
'log_type': 1,
'request_id': request_id,
'time': datetime.datetime.strptime(file_desc['time'], '%Y-%m-%d %H:%M:%S'),
'filename': file_desc['filename'],
'checksum': file_desc['checksum'],
'filetype': file_desc['filetype'],
'save_path': file_relative_path + save_file_name,
'receive_time': du.get_current_time(),
'device_id': detector_id
}
serializer = AuditLogSerializer(data=save_data)
if serializer.is_valid():
serializer.save() # 存储数据库
if config.const.UPLOAD_ES:
sender.async_send_es_net_log(request_id, CR_URL, file_path, detector_id)
if config.const.UPLOAD_BUSINESS:
user_agent = request.META.get('HTTP_USER_AGENT')
business_request_header = construct_header('JCQ_XWSJ_NETLOG_FILE', user_agent, file_desc)
sender.async_send_business_file('project.audit', 'net_log', detector_id, business_request_header,
common.MEDIA_ROOT + save_data['save_path'], file_desc['filename'])
if config.const.UPLOAD_DIRECTOR and check_global_director_connection():
common_header = ccd.get_common_command_header_of_detector('alert', 'JCQ_XWSJ',
'JCQ_XWSJ_NETLOG_FILE', request,
detector_id,
capture_date=datetime.datetime.strptime(
file_desc['time'],
'%Y-%m-%d %H:%M:%S'))
ccd.upload_file_2_director_of_detector(common_header, save_data,
json.dumps((file_desc['filename'], file_path)),
'JCQ_XWSJ_NETLOG_FILE', 'JCQ_XWSJ_NETLOG_FILE',
async_level=3)
return common.detector_message_response(200, '文件存储成功', {'message': 'success'},
status.HTTP_200_OK)
else:
return common.detector_message_response(400, json.dumps(serializer.errors),
'数据处理失败')
else:
return common.detector_message_response(400, '文件上传失败: 文件重名', '文件上传失败')
# elif len(request.FILES) == 0: # 上传数据（文本字符串）
# data = request_data.strip().replace('\n', '~=~')
# requests.post(CR_URL, data={'data': data})
# return common.detector_message_response(200, '数据存储成功', {'message': 'success'},
# status.HTTP_200_OK)
else:
return common.detector_message_response(400, '上传的不是一个文件', '上传数据格式有误')
except Exception:
traceback.print_exc()
return common.detector_message_response(500, '服务器内部错误', '服务器内部错误',
status.HTTP_500_INTERNAL_SERVER_ERROR)
def process_system_audit(request):
try:
report_time = du.get_current_time() # 获取当前时间
request_data = common.print_header_data(request) # 获取请求数据
detector_id = common.check_detector_available(request, Detector) # 检查检测器是否合法，合法就返回检测器ID
if isinstance(detector_id, Response):
return detector_id
data_list = common.detector_upload_json_preprocess(request_data) # 返回List()格式的上传json数据
if isinstance(data_list, Response):
return data_list
# 日志记录
# logger_record.info('%s %s %s %d' % (request.META.get('REMOTE_ADDR'), detector_id, 'detector_audit', len(data_list)))
log_str = '%s %s %s %s %d' % (request.META.get('REMOTE_ADDR'), request.META.get('HTTP_X_REMOTE_ADDR', '0.0.0.0'), detector_id, 'detector_audit', len(data_list))
fu.string2log_append_per_day(content=log_str, path=common.LOG_PATH + 'detector_access_log/')
business_data_list = [] # 发送到业务数据服务器上的列表[(请求头, 数据),...]
handle_data = copy.deepcopy(data_list) # 生成业务处置系统所需文件的告警数据
command_send_data = [] # 发送到指挥中心的数据[(请求头, 数据),...]
for data in data_list:
business_request_data = copy.deepcopy(data) # 业务数据传输请求数据
result = common.check_time_field(data)
if isinstance(request, Response):
return result
if 'id' in data:
data['log_id'] = data.pop('id')
else:
return common.detector_message_response(400, '请求数据中没有id字段', '请求数据中没有id字段')
data['device_id'] = detector_id # 加入检测器id字段
data['report_time'] = report_time # 加入上报时间字段
if config.const.UPLOAD_BUSINESS:
# 构建传输到业务数据服务器上的请求头和请求数据
business_request_header = {
'Host': business_host,
'Date': datetime.datetime.now().strftime('%a, %d %b %Y %H:%M:%S'),
'Content-Type': 'application/json',
'Version': '1.0',
# 'Cookie': 'unknown',
'Source-Type': 'JCQ_XTSJ',
'Data-Type': 'msg',
'User-Agent': request.META.get('HTTP_USER_AGENT'),
'Capture-Date': data['time'].strftime('%a, %d %b %Y %H:%M:%S'),
'BusinessData-Type': 'JCQ_XTSJ',
'Meta-Data': json.dumps({
'id': detector_id
}),
} # 业务数据传输请求头
##### update by wwenan 2019.06.18 17:47####
#business_data_list.append((business_request_header, business_request_data))
###########################################
if config.const.UPLOAD_DIRECTOR and check_global_director_connection():
common_header = ccd.get_common_command_header_of_detector('status', 'AUDIT', 'JCQ_AUDIT',
request, detector_id,
capture_date=data['time'], data_type='msg')
command_data = json.dumps(business_request_data, ensure_ascii=False).encode('utf-8')
ccd.upload_json_2_director_of_detector(common_header, data, command_data, 'JCQ_AUDIT', async_level=3)
serializer = AuditSystemSerializer(data=data_list, many=True) # 序列化
if serializer.is_valid():
serializer.save() # 存储数据库
##### update by wwenan 2019.06.18 17:47#####
#if config.const.UPLOAD_BUSINESS:
#sender.async_send_business_data('project.audit', 'JCQ_XTSJ', detector_id, business_data_list)
############################################
# 生成业务处置系统所需文件
if config.const.UPLOAD_BUSINESS_DISPOSAL:
handle_data_type = 'detector_audit'
file_dir = os.path.join(config.const.DISPOSAL_DIR, 'audit')
file_name = 'detector_audit_' + str(int(time.time())) + '_' + str(1)
sender.send_business_disposal(file_dir, file_name, request.META.get('HTTP_USER_AGENT'), handle_data_type, handle_data)
return common.detector_message_response(200, '数据存储成功', {'message': 'Success'}, status.HTTP_200_OK)
else:
return common.detector_message_response(400, json.dumps(serializer.errors),
'数据缺失或字段不符合规定，序列化出错')
except Exception:
traceback.print_exc()
return common.detector_message_response(500, '服务器内部错误', '服务器内部错误',
status.HTTP_500_INTERNAL_SERVER_ERROR)
def send_register_request(url=dc.send_director_A + 'reg',
src_center_id=dc.SRC_CENTER_ID,
center_serial=dc.CENTER_SERIAL,
src_node=dc.SRC_NODE,
src_ip=dc.director_host,
ip_whitelist=[dc.director_host, '172.17.0.1'],
retract=0):
try:
pu.print_format_header('管理中心发起注册', retract=retract)
headers = {
'Src-Node': src_node,
'Src-Center': src_center_id,
'Content-Type': 'application/json',
'Channel-Tpye': 'JCQ',
'User-Agent': dc.CENTER_USER_AGENT,
'X-Forwarded-For': dc.detect_center_host
}
register_data = get_center_data()
register_data['center_id'] = src_center_id
register_data['center_ip'] = dc.detect_center_host
register_data['center_serial'] = center_serial
register_data['src_node'] = src_node
register_data['src_ip'] = src_ip
register_data['ip_whitelist'] = json.dumps(ip_whitelist)
# del copy_data['access_time']
register_data['register_time'] = du.get_current_date_string()
register_data['id'] = 1
# pretty_print(register_data)
management_center = ManagementCenterInfo.objects.filter(
center_id=dc.SRC_CENTER_ID)
if not management_center.exists():
ManagementCenterInfo.objects.all().delete()
ManagementCenterInfo.objects.create(**register_data)
# serializer = ManagementCenterInfoSerializer(data=register_data)
# if serializer.is_valid():
# serializer.save()
# else:
# print 'save management center', serializer.errors
else:
del register_data['register_time']
management_center.update(**register_data)
management_center = ManagementCenterInfo.objects.filter(
center_id=dc.SRC_CENTER_ID)
data = serialize('json',
management_center,
fields=('center_id', 'soft_version', 'device_ca',
'organs', 'address', 'address_code',
'contact', 'mem_total', 'interface',
'cpu_info', 'disk_info')) # 序列化
list_data = json.loads(data)
register_data = list_data[0]['fields']
register_data['cpu_info'] = json.loads(register_data['cpu_info'])
register_data['disk_info'] = json.loads(register_data['disk_info'])
register_data['interface'] = json.loads(register_data['interface'])
register_data['contact'] = json.loads(register_data['contact'])
print "register_data:", pu.pretty_print_format(register_data)
r = requests.post(url, data=json.dumps(register_data), headers=headers)
# pu.print_with_retract(r.status_code, retract + 1) # 响应码
pu.print_with_retract(r.headers, retract + 1) # 响应头
pu.print_with_retract(r.text.encode('utf-8'), retract + 1) # 响应消息正文
result = json.loads(r.text.encode('utf-8'))
center_info = ManagementCenterInfo.objects.filter(
center_id=dc.SRC_CENTER_ID)
if r.status_code == 200: # （0：注册成功；1：注册失败；2：注册未审核） # (0: 认证成功 1：认证失败 2: 未认证)
# if result["msg"] != u'该管理中心的已存在':
center_info.update(center_status=2,
register_frequency=F('register_frequency') + 1,
register_status=2,
register_fail_reason='未审核',
auth_frequency=0,
auth_status=2,
auth_fail_reason='未认证',
cookie=None)
elif result['msg'] == u'该管理中心的已存在':
if center_info[0].register_status == 0 and center_info[
0].auth_status == 0: # 管理中心主动重置与指挥的连接状态
center_info.update(register_time=du.get_current_time(),
register_frequency=F('register_frequency') +
1)
send_auth_login_request()
config.const.DIRECTOR_VERSION = True
config.const.UPLOAD_DIRECTOR = True
pu.print_format_tail('管理中心发起注册', retract=retract)
return result
except:
traceback.print_exc()
def send_auth_login_request(retract=0, url=dc.send_director_A + 'login'):
try:
pu.print_format_header('管理中心发起认证', retract=retract)
center_info = ManagementCenterInfo.objects.all()
result = None
if center_info.exists():
headers = {
'Src-Node':
center_info[0].src_node,
'Src-Center':
center_info[0].center_id,
'Content-Type':
'application/json',
'Channel-Tpye':
'JCQ',
'User-Agent':
center_info[0].center_id + '/' + center_info[0].soft_version +
'(' + center_info[0].organs + ')',
'X-Forwarded-For':
center_info[0].center_ip
}
if center_info[0].register_status == 2:
pu.print_with_retract(u"管理中心" + center_info[0].center_id +
u"还未审核，请等待审核完毕")
result = {
'code': 400,
'msg': u"管理中心" + center_info[0].center_id + u"还未审核，请等待审核完毕"
}
elif center_info[0].register_status == 1:
pu.print_with_retract(u"管理中心" + center_info[0].center_id +
u"审核失败，请核对指挥中心的管理中心备案信息，重新注册")
send_register_request(
src_center_id=center_info[0].center_id,
center_serial=center_info[0].center_serial,
src_node=center_info[0].src_node,
src_ip=center_info[0].src_ip,
ip_whitelist=center_info[0].ip_whitelist)
result = {
'code':
400,
'msg':
u"管理中心" + center_info[0].center_id +
u"审核失败，请核对指挥中心的管理中心备案信息，重新注册"
}
else:
data = serialize(
'json',
center_info,
fields=('center_id', 'soft_version', 'device_ca', 'organs',
'address', 'address_code', 'contact', 'mem_total',
'interface', 'cpu_info', 'disk_info')) # 序列化
list_data = json.loads(data)
auth_data = list_data[0]['fields']
# auth_data['access_time'] = du.get_current_date_string()
auth_data['cpu_info'] = json.loads(auth_data['cpu_info'])
auth_data['disk_info'] = json.loads(auth_data['disk_info'])
auth_data['interface'] = json.loads(auth_data['interface'])
auth_data['contact'] = json.loads(auth_data['contact'])
print 'auth_data:', pu.pretty_print_format(auth_data)
r = requests.post(url,
data=json.dumps(auth_data),
headers=headers)
# pu.print_with_retract(r.status_code, retract + 1) # 响应码
pu.print_with_retract(r.headers, retract + 1) # 响应头
pu.print_with_retract(r.text.encode('utf-8'),
retract + 1) # 响应消息正文
result = json.loads(r.text.encode('utf-8'))
if result['code'] == 200 and result['msg'] != u'已经接入，无需再次接入':
# print '认证成功'
header_cookie = r.headers.get('Set-Cookie', None)
if header_cookie is not None:
cookie_list = header_cookie.split(';')
if cookie_list is not None:
for cookie in cookie_list:
if str(cookie).find('session') != -1:
l = cookie.split(',')
if l is not None:
for ll in l:
if str(ll).find('session') != -1:
dc.CENTER_COOKIE = {
str(
ll.split('=')[0].strip(
)):
str(ll.split('=')[1])
}
if header_cookie is not None:
center_info.update(center_status=1,
auth_time=du.get_current_time(),
auth_frequency=F('auth_frequency') +
1,
auth_status=0,
auth_fail_reason='认证成功',
cookie=json.dumps(dc.CENTER_COOKIE))
else:
center_info.update(center_status=1,
auth_time=du.get_current_time(),
auth_frequency=F('auth_frequency') +
1,
auth_status=0,
auth_fail_reason='认证成功')
dc.CENTER_COOKIE = json.loads(center_info[0].cookie,
encoding='utf-8')
from audit.data_processing import send_detector_info, send_audit
from rest_framework.request import Request
from director import heartbeat
heartbeat.heartbeat_2_director() # 发送心跳
if center_info[0].auth_frequency == 1:
send_detector_info(Request, retract=retract +
1) # 发送管理中心所有的检测器信息
send_audit(Request, retract=retract + 1) # 发送管理中心自身审计日志
elif result['msg'] == u'已经接入，无需再次接入':
center_info.update(auth_time=du.get_current_time(),
auth_frequency=F('auth_frequency') + 1,
auth_status=0,
auth_fail_reason='认证成功',
center_status=1)
else:
# print '认证失败'
center_info.update(center_status=5,
auth_time=du.get_current_time(),
auth_frequency=F('auth_frequency') + 1,
auth_status=1,
auth_fail_reason=result['msg'],
cookie=None)
pu.print_format_tail('管理中心发起认证', retract=retract)
return result
except:
traceback.print_exc()